trezor_client/protos/generated/
messages_management.rs

1// This file is generated by rust-protobuf 3.3.0. Do not edit
2// .proto file is parsed by protoc 3.19.6
3// @generated
4
5// https://github.com/rust-lang/rust-clippy/issues/702
6#![allow(unknown_lints)]
7#![allow(clippy::all)]
8
9#![allow(unused_attributes)]
10#![cfg_attr(rustfmt, rustfmt::skip)]
11
12#![allow(box_pointers)]
13#![allow(dead_code)]
14#![allow(missing_docs)]
15#![allow(non_camel_case_types)]
16#![allow(non_snake_case)]
17#![allow(non_upper_case_globals)]
18#![allow(trivial_casts)]
19#![allow(unused_results)]
20#![allow(unused_mut)]
21
22//! Generated file from `messages-management.proto`
23
24/// Generated files are compatible only with the same version
25/// of protobuf runtime.
26const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_3_0;
27
28// @@protoc_insertion_point(message:hw.trezor.messages.management.Initialize)
29#[derive(PartialEq,Clone,Default,Debug)]
30pub struct Initialize {
31    // message fields
32    // @@protoc_insertion_point(field:hw.trezor.messages.management.Initialize.session_id)
33    pub session_id: ::std::option::Option<::std::vec::Vec<u8>>,
34    // @@protoc_insertion_point(field:hw.trezor.messages.management.Initialize._skip_passphrase)
35    pub _skip_passphrase: ::std::option::Option<bool>,
36    // @@protoc_insertion_point(field:hw.trezor.messages.management.Initialize.derive_cardano)
37    pub derive_cardano: ::std::option::Option<bool>,
38    // special fields
39    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Initialize.special_fields)
40    pub special_fields: ::protobuf::SpecialFields,
41}
42
43impl<'a> ::std::default::Default for &'a Initialize {
44    fn default() -> &'a Initialize {
45        <Initialize as ::protobuf::Message>::default_instance()
46    }
47}
48
49impl Initialize {
50    pub fn new() -> Initialize {
51        ::std::default::Default::default()
52    }
53
54    // optional bytes session_id = 1;
55
56    pub fn session_id(&self) -> &[u8] {
57        match self.session_id.as_ref() {
58            Some(v) => v,
59            None => &[],
60        }
61    }
62
63    pub fn clear_session_id(&mut self) {
64        self.session_id = ::std::option::Option::None;
65    }
66
67    pub fn has_session_id(&self) -> bool {
68        self.session_id.is_some()
69    }
70
71    // Param is passed by value, moved
72    pub fn set_session_id(&mut self, v: ::std::vec::Vec<u8>) {
73        self.session_id = ::std::option::Option::Some(v);
74    }
75
76    // Mutable pointer to the field.
77    // If field is not initialized, it is initialized with default value first.
78    pub fn mut_session_id(&mut self) -> &mut ::std::vec::Vec<u8> {
79        if self.session_id.is_none() {
80            self.session_id = ::std::option::Option::Some(::std::vec::Vec::new());
81        }
82        self.session_id.as_mut().unwrap()
83    }
84
85    // Take field
86    pub fn take_session_id(&mut self) -> ::std::vec::Vec<u8> {
87        self.session_id.take().unwrap_or_else(|| ::std::vec::Vec::new())
88    }
89
90    // optional bool _skip_passphrase = 2;
91
92    pub fn _skip_passphrase(&self) -> bool {
93        self._skip_passphrase.unwrap_or(false)
94    }
95
96    pub fn clear__skip_passphrase(&mut self) {
97        self._skip_passphrase = ::std::option::Option::None;
98    }
99
100    pub fn has__skip_passphrase(&self) -> bool {
101        self._skip_passphrase.is_some()
102    }
103
104    // Param is passed by value, moved
105    pub fn set__skip_passphrase(&mut self, v: bool) {
106        self._skip_passphrase = ::std::option::Option::Some(v);
107    }
108
109    // optional bool derive_cardano = 3;
110
111    pub fn derive_cardano(&self) -> bool {
112        self.derive_cardano.unwrap_or(false)
113    }
114
115    pub fn clear_derive_cardano(&mut self) {
116        self.derive_cardano = ::std::option::Option::None;
117    }
118
119    pub fn has_derive_cardano(&self) -> bool {
120        self.derive_cardano.is_some()
121    }
122
123    // Param is passed by value, moved
124    pub fn set_derive_cardano(&mut self, v: bool) {
125        self.derive_cardano = ::std::option::Option::Some(v);
126    }
127
128    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
129        let mut fields = ::std::vec::Vec::with_capacity(3);
130        let mut oneofs = ::std::vec::Vec::with_capacity(0);
131        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
132            "session_id",
133            |m: &Initialize| { &m.session_id },
134            |m: &mut Initialize| { &mut m.session_id },
135        ));
136        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
137            "_skip_passphrase",
138            |m: &Initialize| { &m._skip_passphrase },
139            |m: &mut Initialize| { &mut m._skip_passphrase },
140        ));
141        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
142            "derive_cardano",
143            |m: &Initialize| { &m.derive_cardano },
144            |m: &mut Initialize| { &mut m.derive_cardano },
145        ));
146        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Initialize>(
147            "Initialize",
148            fields,
149            oneofs,
150        )
151    }
152}
153
154impl ::protobuf::Message for Initialize {
155    const NAME: &'static str = "Initialize";
156
157    fn is_initialized(&self) -> bool {
158        true
159    }
160
161    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
162        while let Some(tag) = is.read_raw_tag_or_eof()? {
163            match tag {
164                10 => {
165                    self.session_id = ::std::option::Option::Some(is.read_bytes()?);
166                },
167                16 => {
168                    self._skip_passphrase = ::std::option::Option::Some(is.read_bool()?);
169                },
170                24 => {
171                    self.derive_cardano = ::std::option::Option::Some(is.read_bool()?);
172                },
173                tag => {
174                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
175                },
176            };
177        }
178        ::std::result::Result::Ok(())
179    }
180
181    // Compute sizes of nested messages
182    #[allow(unused_variables)]
183    fn compute_size(&self) -> u64 {
184        let mut my_size = 0;
185        if let Some(v) = self.session_id.as_ref() {
186            my_size += ::protobuf::rt::bytes_size(1, &v);
187        }
188        if let Some(v) = self._skip_passphrase {
189            my_size += 1 + 1;
190        }
191        if let Some(v) = self.derive_cardano {
192            my_size += 1 + 1;
193        }
194        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
195        self.special_fields.cached_size().set(my_size as u32);
196        my_size
197    }
198
199    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
200        if let Some(v) = self.session_id.as_ref() {
201            os.write_bytes(1, v)?;
202        }
203        if let Some(v) = self._skip_passphrase {
204            os.write_bool(2, v)?;
205        }
206        if let Some(v) = self.derive_cardano {
207            os.write_bool(3, v)?;
208        }
209        os.write_unknown_fields(self.special_fields.unknown_fields())?;
210        ::std::result::Result::Ok(())
211    }
212
213    fn special_fields(&self) -> &::protobuf::SpecialFields {
214        &self.special_fields
215    }
216
217    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
218        &mut self.special_fields
219    }
220
221    fn new() -> Initialize {
222        Initialize::new()
223    }
224
225    fn clear(&mut self) {
226        self.session_id = ::std::option::Option::None;
227        self._skip_passphrase = ::std::option::Option::None;
228        self.derive_cardano = ::std::option::Option::None;
229        self.special_fields.clear();
230    }
231
232    fn default_instance() -> &'static Initialize {
233        static instance: Initialize = Initialize {
234            session_id: ::std::option::Option::None,
235            _skip_passphrase: ::std::option::Option::None,
236            derive_cardano: ::std::option::Option::None,
237            special_fields: ::protobuf::SpecialFields::new(),
238        };
239        &instance
240    }
241}
242
243impl ::protobuf::MessageFull for Initialize {
244    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
245        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
246        descriptor.get(|| file_descriptor().message_by_package_relative_name("Initialize").unwrap()).clone()
247    }
248}
249
250impl ::std::fmt::Display for Initialize {
251    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
252        ::protobuf::text_format::fmt(self, f)
253    }
254}
255
256impl ::protobuf::reflect::ProtobufValue for Initialize {
257    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
258}
259
260// @@protoc_insertion_point(message:hw.trezor.messages.management.GetFeatures)
261#[derive(PartialEq,Clone,Default,Debug)]
262pub struct GetFeatures {
263    // special fields
264    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.GetFeatures.special_fields)
265    pub special_fields: ::protobuf::SpecialFields,
266}
267
268impl<'a> ::std::default::Default for &'a GetFeatures {
269    fn default() -> &'a GetFeatures {
270        <GetFeatures as ::protobuf::Message>::default_instance()
271    }
272}
273
274impl GetFeatures {
275    pub fn new() -> GetFeatures {
276        ::std::default::Default::default()
277    }
278
279    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
280        let mut fields = ::std::vec::Vec::with_capacity(0);
281        let mut oneofs = ::std::vec::Vec::with_capacity(0);
282        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetFeatures>(
283            "GetFeatures",
284            fields,
285            oneofs,
286        )
287    }
288}
289
290impl ::protobuf::Message for GetFeatures {
291    const NAME: &'static str = "GetFeatures";
292
293    fn is_initialized(&self) -> bool {
294        true
295    }
296
297    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
298        while let Some(tag) = is.read_raw_tag_or_eof()? {
299            match tag {
300                tag => {
301                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
302                },
303            };
304        }
305        ::std::result::Result::Ok(())
306    }
307
308    // Compute sizes of nested messages
309    #[allow(unused_variables)]
310    fn compute_size(&self) -> u64 {
311        let mut my_size = 0;
312        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
313        self.special_fields.cached_size().set(my_size as u32);
314        my_size
315    }
316
317    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
318        os.write_unknown_fields(self.special_fields.unknown_fields())?;
319        ::std::result::Result::Ok(())
320    }
321
322    fn special_fields(&self) -> &::protobuf::SpecialFields {
323        &self.special_fields
324    }
325
326    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
327        &mut self.special_fields
328    }
329
330    fn new() -> GetFeatures {
331        GetFeatures::new()
332    }
333
334    fn clear(&mut self) {
335        self.special_fields.clear();
336    }
337
338    fn default_instance() -> &'static GetFeatures {
339        static instance: GetFeatures = GetFeatures {
340            special_fields: ::protobuf::SpecialFields::new(),
341        };
342        &instance
343    }
344}
345
346impl ::protobuf::MessageFull for GetFeatures {
347    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
348        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
349        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetFeatures").unwrap()).clone()
350    }
351}
352
353impl ::std::fmt::Display for GetFeatures {
354    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
355        ::protobuf::text_format::fmt(self, f)
356    }
357}
358
359impl ::protobuf::reflect::ProtobufValue for GetFeatures {
360    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
361}
362
363// @@protoc_insertion_point(message:hw.trezor.messages.management.Features)
364#[derive(PartialEq,Clone,Default,Debug)]
365pub struct Features {
366    // message fields
367    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.vendor)
368    pub vendor: ::std::option::Option<::std::string::String>,
369    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.major_version)
370    pub major_version: ::std::option::Option<u32>,
371    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.minor_version)
372    pub minor_version: ::std::option::Option<u32>,
373    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.patch_version)
374    pub patch_version: ::std::option::Option<u32>,
375    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.bootloader_mode)
376    pub bootloader_mode: ::std::option::Option<bool>,
377    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.device_id)
378    pub device_id: ::std::option::Option<::std::string::String>,
379    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.pin_protection)
380    pub pin_protection: ::std::option::Option<bool>,
381    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.passphrase_protection)
382    pub passphrase_protection: ::std::option::Option<bool>,
383    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.language)
384    pub language: ::std::option::Option<::std::string::String>,
385    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.label)
386    pub label: ::std::option::Option<::std::string::String>,
387    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.initialized)
388    pub initialized: ::std::option::Option<bool>,
389    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.revision)
390    pub revision: ::std::option::Option<::std::vec::Vec<u8>>,
391    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.bootloader_hash)
392    pub bootloader_hash: ::std::option::Option<::std::vec::Vec<u8>>,
393    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.imported)
394    pub imported: ::std::option::Option<bool>,
395    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.unlocked)
396    pub unlocked: ::std::option::Option<bool>,
397    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features._passphrase_cached)
398    pub _passphrase_cached: ::std::option::Option<bool>,
399    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.firmware_present)
400    pub firmware_present: ::std::option::Option<bool>,
401    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.backup_availability)
402    pub backup_availability: ::std::option::Option<::protobuf::EnumOrUnknown<features::BackupAvailability>>,
403    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.flags)
404    pub flags: ::std::option::Option<u32>,
405    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.model)
406    pub model: ::std::option::Option<::std::string::String>,
407    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.fw_major)
408    pub fw_major: ::std::option::Option<u32>,
409    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.fw_minor)
410    pub fw_minor: ::std::option::Option<u32>,
411    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.fw_patch)
412    pub fw_patch: ::std::option::Option<u32>,
413    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.fw_vendor)
414    pub fw_vendor: ::std::option::Option<::std::string::String>,
415    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.unfinished_backup)
416    pub unfinished_backup: ::std::option::Option<bool>,
417    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.no_backup)
418    pub no_backup: ::std::option::Option<bool>,
419    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.recovery_status)
420    pub recovery_status: ::std::option::Option<::protobuf::EnumOrUnknown<features::RecoveryStatus>>,
421    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.capabilities)
422    pub capabilities: ::std::vec::Vec<::protobuf::EnumOrUnknown<features::Capability>>,
423    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.backup_type)
424    pub backup_type: ::std::option::Option<::protobuf::EnumOrUnknown<BackupType>>,
425    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.sd_card_present)
426    pub sd_card_present: ::std::option::Option<bool>,
427    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.sd_protection)
428    pub sd_protection: ::std::option::Option<bool>,
429    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.wipe_code_protection)
430    pub wipe_code_protection: ::std::option::Option<bool>,
431    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.session_id)
432    pub session_id: ::std::option::Option<::std::vec::Vec<u8>>,
433    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.passphrase_always_on_device)
434    pub passphrase_always_on_device: ::std::option::Option<bool>,
435    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.safety_checks)
436    pub safety_checks: ::std::option::Option<::protobuf::EnumOrUnknown<SafetyCheckLevel>>,
437    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.auto_lock_delay_ms)
438    pub auto_lock_delay_ms: ::std::option::Option<u32>,
439    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.display_rotation)
440    pub display_rotation: ::std::option::Option<u32>,
441    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.experimental_features)
442    pub experimental_features: ::std::option::Option<bool>,
443    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.busy)
444    pub busy: ::std::option::Option<bool>,
445    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.homescreen_format)
446    pub homescreen_format: ::std::option::Option<::protobuf::EnumOrUnknown<HomescreenFormat>>,
447    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.hide_passphrase_from_host)
448    pub hide_passphrase_from_host: ::std::option::Option<bool>,
449    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.internal_model)
450    pub internal_model: ::std::option::Option<::std::string::String>,
451    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.unit_color)
452    pub unit_color: ::std::option::Option<u32>,
453    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.unit_btconly)
454    pub unit_btconly: ::std::option::Option<bool>,
455    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.homescreen_width)
456    pub homescreen_width: ::std::option::Option<u32>,
457    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.homescreen_height)
458    pub homescreen_height: ::std::option::Option<u32>,
459    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.bootloader_locked)
460    pub bootloader_locked: ::std::option::Option<bool>,
461    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.language_version_matches)
462    pub language_version_matches: ::std::option::Option<bool>,
463    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.unit_packaging)
464    pub unit_packaging: ::std::option::Option<u32>,
465    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.haptic_feedback)
466    pub haptic_feedback: ::std::option::Option<bool>,
467    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.recovery_type)
468    pub recovery_type: ::std::option::Option<::protobuf::EnumOrUnknown<RecoveryType>>,
469    // @@protoc_insertion_point(field:hw.trezor.messages.management.Features.optiga_sec)
470    pub optiga_sec: ::std::option::Option<u32>,
471    // special fields
472    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Features.special_fields)
473    pub special_fields: ::protobuf::SpecialFields,
474}
475
476impl<'a> ::std::default::Default for &'a Features {
477    fn default() -> &'a Features {
478        <Features as ::protobuf::Message>::default_instance()
479    }
480}
481
482impl Features {
483    pub fn new() -> Features {
484        ::std::default::Default::default()
485    }
486
487    // optional string vendor = 1;
488
489    pub fn vendor(&self) -> &str {
490        match self.vendor.as_ref() {
491            Some(v) => v,
492            None => "",
493        }
494    }
495
496    pub fn clear_vendor(&mut self) {
497        self.vendor = ::std::option::Option::None;
498    }
499
500    pub fn has_vendor(&self) -> bool {
501        self.vendor.is_some()
502    }
503
504    // Param is passed by value, moved
505    pub fn set_vendor(&mut self, v: ::std::string::String) {
506        self.vendor = ::std::option::Option::Some(v);
507    }
508
509    // Mutable pointer to the field.
510    // If field is not initialized, it is initialized with default value first.
511    pub fn mut_vendor(&mut self) -> &mut ::std::string::String {
512        if self.vendor.is_none() {
513            self.vendor = ::std::option::Option::Some(::std::string::String::new());
514        }
515        self.vendor.as_mut().unwrap()
516    }
517
518    // Take field
519    pub fn take_vendor(&mut self) -> ::std::string::String {
520        self.vendor.take().unwrap_or_else(|| ::std::string::String::new())
521    }
522
523    // required uint32 major_version = 2;
524
525    pub fn major_version(&self) -> u32 {
526        self.major_version.unwrap_or(0)
527    }
528
529    pub fn clear_major_version(&mut self) {
530        self.major_version = ::std::option::Option::None;
531    }
532
533    pub fn has_major_version(&self) -> bool {
534        self.major_version.is_some()
535    }
536
537    // Param is passed by value, moved
538    pub fn set_major_version(&mut self, v: u32) {
539        self.major_version = ::std::option::Option::Some(v);
540    }
541
542    // required uint32 minor_version = 3;
543
544    pub fn minor_version(&self) -> u32 {
545        self.minor_version.unwrap_or(0)
546    }
547
548    pub fn clear_minor_version(&mut self) {
549        self.minor_version = ::std::option::Option::None;
550    }
551
552    pub fn has_minor_version(&self) -> bool {
553        self.minor_version.is_some()
554    }
555
556    // Param is passed by value, moved
557    pub fn set_minor_version(&mut self, v: u32) {
558        self.minor_version = ::std::option::Option::Some(v);
559    }
560
561    // required uint32 patch_version = 4;
562
563    pub fn patch_version(&self) -> u32 {
564        self.patch_version.unwrap_or(0)
565    }
566
567    pub fn clear_patch_version(&mut self) {
568        self.patch_version = ::std::option::Option::None;
569    }
570
571    pub fn has_patch_version(&self) -> bool {
572        self.patch_version.is_some()
573    }
574
575    // Param is passed by value, moved
576    pub fn set_patch_version(&mut self, v: u32) {
577        self.patch_version = ::std::option::Option::Some(v);
578    }
579
580    // optional bool bootloader_mode = 5;
581
582    pub fn bootloader_mode(&self) -> bool {
583        self.bootloader_mode.unwrap_or(false)
584    }
585
586    pub fn clear_bootloader_mode(&mut self) {
587        self.bootloader_mode = ::std::option::Option::None;
588    }
589
590    pub fn has_bootloader_mode(&self) -> bool {
591        self.bootloader_mode.is_some()
592    }
593
594    // Param is passed by value, moved
595    pub fn set_bootloader_mode(&mut self, v: bool) {
596        self.bootloader_mode = ::std::option::Option::Some(v);
597    }
598
599    // optional string device_id = 6;
600
601    pub fn device_id(&self) -> &str {
602        match self.device_id.as_ref() {
603            Some(v) => v,
604            None => "",
605        }
606    }
607
608    pub fn clear_device_id(&mut self) {
609        self.device_id = ::std::option::Option::None;
610    }
611
612    pub fn has_device_id(&self) -> bool {
613        self.device_id.is_some()
614    }
615
616    // Param is passed by value, moved
617    pub fn set_device_id(&mut self, v: ::std::string::String) {
618        self.device_id = ::std::option::Option::Some(v);
619    }
620
621    // Mutable pointer to the field.
622    // If field is not initialized, it is initialized with default value first.
623    pub fn mut_device_id(&mut self) -> &mut ::std::string::String {
624        if self.device_id.is_none() {
625            self.device_id = ::std::option::Option::Some(::std::string::String::new());
626        }
627        self.device_id.as_mut().unwrap()
628    }
629
630    // Take field
631    pub fn take_device_id(&mut self) -> ::std::string::String {
632        self.device_id.take().unwrap_or_else(|| ::std::string::String::new())
633    }
634
635    // optional bool pin_protection = 7;
636
637    pub fn pin_protection(&self) -> bool {
638        self.pin_protection.unwrap_or(false)
639    }
640
641    pub fn clear_pin_protection(&mut self) {
642        self.pin_protection = ::std::option::Option::None;
643    }
644
645    pub fn has_pin_protection(&self) -> bool {
646        self.pin_protection.is_some()
647    }
648
649    // Param is passed by value, moved
650    pub fn set_pin_protection(&mut self, v: bool) {
651        self.pin_protection = ::std::option::Option::Some(v);
652    }
653
654    // optional bool passphrase_protection = 8;
655
656    pub fn passphrase_protection(&self) -> bool {
657        self.passphrase_protection.unwrap_or(false)
658    }
659
660    pub fn clear_passphrase_protection(&mut self) {
661        self.passphrase_protection = ::std::option::Option::None;
662    }
663
664    pub fn has_passphrase_protection(&self) -> bool {
665        self.passphrase_protection.is_some()
666    }
667
668    // Param is passed by value, moved
669    pub fn set_passphrase_protection(&mut self, v: bool) {
670        self.passphrase_protection = ::std::option::Option::Some(v);
671    }
672
673    // optional string language = 9;
674
675    pub fn language(&self) -> &str {
676        match self.language.as_ref() {
677            Some(v) => v,
678            None => "",
679        }
680    }
681
682    pub fn clear_language(&mut self) {
683        self.language = ::std::option::Option::None;
684    }
685
686    pub fn has_language(&self) -> bool {
687        self.language.is_some()
688    }
689
690    // Param is passed by value, moved
691    pub fn set_language(&mut self, v: ::std::string::String) {
692        self.language = ::std::option::Option::Some(v);
693    }
694
695    // Mutable pointer to the field.
696    // If field is not initialized, it is initialized with default value first.
697    pub fn mut_language(&mut self) -> &mut ::std::string::String {
698        if self.language.is_none() {
699            self.language = ::std::option::Option::Some(::std::string::String::new());
700        }
701        self.language.as_mut().unwrap()
702    }
703
704    // Take field
705    pub fn take_language(&mut self) -> ::std::string::String {
706        self.language.take().unwrap_or_else(|| ::std::string::String::new())
707    }
708
709    // optional string label = 10;
710
711    pub fn label(&self) -> &str {
712        match self.label.as_ref() {
713            Some(v) => v,
714            None => "",
715        }
716    }
717
718    pub fn clear_label(&mut self) {
719        self.label = ::std::option::Option::None;
720    }
721
722    pub fn has_label(&self) -> bool {
723        self.label.is_some()
724    }
725
726    // Param is passed by value, moved
727    pub fn set_label(&mut self, v: ::std::string::String) {
728        self.label = ::std::option::Option::Some(v);
729    }
730
731    // Mutable pointer to the field.
732    // If field is not initialized, it is initialized with default value first.
733    pub fn mut_label(&mut self) -> &mut ::std::string::String {
734        if self.label.is_none() {
735            self.label = ::std::option::Option::Some(::std::string::String::new());
736        }
737        self.label.as_mut().unwrap()
738    }
739
740    // Take field
741    pub fn take_label(&mut self) -> ::std::string::String {
742        self.label.take().unwrap_or_else(|| ::std::string::String::new())
743    }
744
745    // optional bool initialized = 12;
746
747    pub fn initialized(&self) -> bool {
748        self.initialized.unwrap_or(false)
749    }
750
751    pub fn clear_initialized(&mut self) {
752        self.initialized = ::std::option::Option::None;
753    }
754
755    pub fn has_initialized(&self) -> bool {
756        self.initialized.is_some()
757    }
758
759    // Param is passed by value, moved
760    pub fn set_initialized(&mut self, v: bool) {
761        self.initialized = ::std::option::Option::Some(v);
762    }
763
764    // optional bytes revision = 13;
765
766    pub fn revision(&self) -> &[u8] {
767        match self.revision.as_ref() {
768            Some(v) => v,
769            None => &[],
770        }
771    }
772
773    pub fn clear_revision(&mut self) {
774        self.revision = ::std::option::Option::None;
775    }
776
777    pub fn has_revision(&self) -> bool {
778        self.revision.is_some()
779    }
780
781    // Param is passed by value, moved
782    pub fn set_revision(&mut self, v: ::std::vec::Vec<u8>) {
783        self.revision = ::std::option::Option::Some(v);
784    }
785
786    // Mutable pointer to the field.
787    // If field is not initialized, it is initialized with default value first.
788    pub fn mut_revision(&mut self) -> &mut ::std::vec::Vec<u8> {
789        if self.revision.is_none() {
790            self.revision = ::std::option::Option::Some(::std::vec::Vec::new());
791        }
792        self.revision.as_mut().unwrap()
793    }
794
795    // Take field
796    pub fn take_revision(&mut self) -> ::std::vec::Vec<u8> {
797        self.revision.take().unwrap_or_else(|| ::std::vec::Vec::new())
798    }
799
800    // optional bytes bootloader_hash = 14;
801
802    pub fn bootloader_hash(&self) -> &[u8] {
803        match self.bootloader_hash.as_ref() {
804            Some(v) => v,
805            None => &[],
806        }
807    }
808
809    pub fn clear_bootloader_hash(&mut self) {
810        self.bootloader_hash = ::std::option::Option::None;
811    }
812
813    pub fn has_bootloader_hash(&self) -> bool {
814        self.bootloader_hash.is_some()
815    }
816
817    // Param is passed by value, moved
818    pub fn set_bootloader_hash(&mut self, v: ::std::vec::Vec<u8>) {
819        self.bootloader_hash = ::std::option::Option::Some(v);
820    }
821
822    // Mutable pointer to the field.
823    // If field is not initialized, it is initialized with default value first.
824    pub fn mut_bootloader_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
825        if self.bootloader_hash.is_none() {
826            self.bootloader_hash = ::std::option::Option::Some(::std::vec::Vec::new());
827        }
828        self.bootloader_hash.as_mut().unwrap()
829    }
830
831    // Take field
832    pub fn take_bootloader_hash(&mut self) -> ::std::vec::Vec<u8> {
833        self.bootloader_hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
834    }
835
836    // optional bool imported = 15;
837
838    pub fn imported(&self) -> bool {
839        self.imported.unwrap_or(false)
840    }
841
842    pub fn clear_imported(&mut self) {
843        self.imported = ::std::option::Option::None;
844    }
845
846    pub fn has_imported(&self) -> bool {
847        self.imported.is_some()
848    }
849
850    // Param is passed by value, moved
851    pub fn set_imported(&mut self, v: bool) {
852        self.imported = ::std::option::Option::Some(v);
853    }
854
855    // optional bool unlocked = 16;
856
857    pub fn unlocked(&self) -> bool {
858        self.unlocked.unwrap_or(false)
859    }
860
861    pub fn clear_unlocked(&mut self) {
862        self.unlocked = ::std::option::Option::None;
863    }
864
865    pub fn has_unlocked(&self) -> bool {
866        self.unlocked.is_some()
867    }
868
869    // Param is passed by value, moved
870    pub fn set_unlocked(&mut self, v: bool) {
871        self.unlocked = ::std::option::Option::Some(v);
872    }
873
874    // optional bool _passphrase_cached = 17;
875
876    pub fn _passphrase_cached(&self) -> bool {
877        self._passphrase_cached.unwrap_or(false)
878    }
879
880    pub fn clear__passphrase_cached(&mut self) {
881        self._passphrase_cached = ::std::option::Option::None;
882    }
883
884    pub fn has__passphrase_cached(&self) -> bool {
885        self._passphrase_cached.is_some()
886    }
887
888    // Param is passed by value, moved
889    pub fn set__passphrase_cached(&mut self, v: bool) {
890        self._passphrase_cached = ::std::option::Option::Some(v);
891    }
892
893    // optional bool firmware_present = 18;
894
895    pub fn firmware_present(&self) -> bool {
896        self.firmware_present.unwrap_or(false)
897    }
898
899    pub fn clear_firmware_present(&mut self) {
900        self.firmware_present = ::std::option::Option::None;
901    }
902
903    pub fn has_firmware_present(&self) -> bool {
904        self.firmware_present.is_some()
905    }
906
907    // Param is passed by value, moved
908    pub fn set_firmware_present(&mut self, v: bool) {
909        self.firmware_present = ::std::option::Option::Some(v);
910    }
911
912    // optional .hw.trezor.messages.management.Features.BackupAvailability backup_availability = 19;
913
914    pub fn backup_availability(&self) -> features::BackupAvailability {
915        match self.backup_availability {
916            Some(e) => e.enum_value_or(features::BackupAvailability::NotAvailable),
917            None => features::BackupAvailability::NotAvailable,
918        }
919    }
920
921    pub fn clear_backup_availability(&mut self) {
922        self.backup_availability = ::std::option::Option::None;
923    }
924
925    pub fn has_backup_availability(&self) -> bool {
926        self.backup_availability.is_some()
927    }
928
929    // Param is passed by value, moved
930    pub fn set_backup_availability(&mut self, v: features::BackupAvailability) {
931        self.backup_availability = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
932    }
933
934    // optional uint32 flags = 20;
935
936    pub fn flags(&self) -> u32 {
937        self.flags.unwrap_or(0)
938    }
939
940    pub fn clear_flags(&mut self) {
941        self.flags = ::std::option::Option::None;
942    }
943
944    pub fn has_flags(&self) -> bool {
945        self.flags.is_some()
946    }
947
948    // Param is passed by value, moved
949    pub fn set_flags(&mut self, v: u32) {
950        self.flags = ::std::option::Option::Some(v);
951    }
952
953    // optional string model = 21;
954
955    pub fn model(&self) -> &str {
956        match self.model.as_ref() {
957            Some(v) => v,
958            None => "",
959        }
960    }
961
962    pub fn clear_model(&mut self) {
963        self.model = ::std::option::Option::None;
964    }
965
966    pub fn has_model(&self) -> bool {
967        self.model.is_some()
968    }
969
970    // Param is passed by value, moved
971    pub fn set_model(&mut self, v: ::std::string::String) {
972        self.model = ::std::option::Option::Some(v);
973    }
974
975    // Mutable pointer to the field.
976    // If field is not initialized, it is initialized with default value first.
977    pub fn mut_model(&mut self) -> &mut ::std::string::String {
978        if self.model.is_none() {
979            self.model = ::std::option::Option::Some(::std::string::String::new());
980        }
981        self.model.as_mut().unwrap()
982    }
983
984    // Take field
985    pub fn take_model(&mut self) -> ::std::string::String {
986        self.model.take().unwrap_or_else(|| ::std::string::String::new())
987    }
988
989    // optional uint32 fw_major = 22;
990
991    pub fn fw_major(&self) -> u32 {
992        self.fw_major.unwrap_or(0)
993    }
994
995    pub fn clear_fw_major(&mut self) {
996        self.fw_major = ::std::option::Option::None;
997    }
998
999    pub fn has_fw_major(&self) -> bool {
1000        self.fw_major.is_some()
1001    }
1002
1003    // Param is passed by value, moved
1004    pub fn set_fw_major(&mut self, v: u32) {
1005        self.fw_major = ::std::option::Option::Some(v);
1006    }
1007
1008    // optional uint32 fw_minor = 23;
1009
1010    pub fn fw_minor(&self) -> u32 {
1011        self.fw_minor.unwrap_or(0)
1012    }
1013
1014    pub fn clear_fw_minor(&mut self) {
1015        self.fw_minor = ::std::option::Option::None;
1016    }
1017
1018    pub fn has_fw_minor(&self) -> bool {
1019        self.fw_minor.is_some()
1020    }
1021
1022    // Param is passed by value, moved
1023    pub fn set_fw_minor(&mut self, v: u32) {
1024        self.fw_minor = ::std::option::Option::Some(v);
1025    }
1026
1027    // optional uint32 fw_patch = 24;
1028
1029    pub fn fw_patch(&self) -> u32 {
1030        self.fw_patch.unwrap_or(0)
1031    }
1032
1033    pub fn clear_fw_patch(&mut self) {
1034        self.fw_patch = ::std::option::Option::None;
1035    }
1036
1037    pub fn has_fw_patch(&self) -> bool {
1038        self.fw_patch.is_some()
1039    }
1040
1041    // Param is passed by value, moved
1042    pub fn set_fw_patch(&mut self, v: u32) {
1043        self.fw_patch = ::std::option::Option::Some(v);
1044    }
1045
1046    // optional string fw_vendor = 25;
1047
1048    pub fn fw_vendor(&self) -> &str {
1049        match self.fw_vendor.as_ref() {
1050            Some(v) => v,
1051            None => "",
1052        }
1053    }
1054
1055    pub fn clear_fw_vendor(&mut self) {
1056        self.fw_vendor = ::std::option::Option::None;
1057    }
1058
1059    pub fn has_fw_vendor(&self) -> bool {
1060        self.fw_vendor.is_some()
1061    }
1062
1063    // Param is passed by value, moved
1064    pub fn set_fw_vendor(&mut self, v: ::std::string::String) {
1065        self.fw_vendor = ::std::option::Option::Some(v);
1066    }
1067
1068    // Mutable pointer to the field.
1069    // If field is not initialized, it is initialized with default value first.
1070    pub fn mut_fw_vendor(&mut self) -> &mut ::std::string::String {
1071        if self.fw_vendor.is_none() {
1072            self.fw_vendor = ::std::option::Option::Some(::std::string::String::new());
1073        }
1074        self.fw_vendor.as_mut().unwrap()
1075    }
1076
1077    // Take field
1078    pub fn take_fw_vendor(&mut self) -> ::std::string::String {
1079        self.fw_vendor.take().unwrap_or_else(|| ::std::string::String::new())
1080    }
1081
1082    // optional bool unfinished_backup = 27;
1083
1084    pub fn unfinished_backup(&self) -> bool {
1085        self.unfinished_backup.unwrap_or(false)
1086    }
1087
1088    pub fn clear_unfinished_backup(&mut self) {
1089        self.unfinished_backup = ::std::option::Option::None;
1090    }
1091
1092    pub fn has_unfinished_backup(&self) -> bool {
1093        self.unfinished_backup.is_some()
1094    }
1095
1096    // Param is passed by value, moved
1097    pub fn set_unfinished_backup(&mut self, v: bool) {
1098        self.unfinished_backup = ::std::option::Option::Some(v);
1099    }
1100
1101    // optional bool no_backup = 28;
1102
1103    pub fn no_backup(&self) -> bool {
1104        self.no_backup.unwrap_or(false)
1105    }
1106
1107    pub fn clear_no_backup(&mut self) {
1108        self.no_backup = ::std::option::Option::None;
1109    }
1110
1111    pub fn has_no_backup(&self) -> bool {
1112        self.no_backup.is_some()
1113    }
1114
1115    // Param is passed by value, moved
1116    pub fn set_no_backup(&mut self, v: bool) {
1117        self.no_backup = ::std::option::Option::Some(v);
1118    }
1119
1120    // optional .hw.trezor.messages.management.Features.RecoveryStatus recovery_status = 29;
1121
1122    pub fn recovery_status(&self) -> features::RecoveryStatus {
1123        match self.recovery_status {
1124            Some(e) => e.enum_value_or(features::RecoveryStatus::Nothing),
1125            None => features::RecoveryStatus::Nothing,
1126        }
1127    }
1128
1129    pub fn clear_recovery_status(&mut self) {
1130        self.recovery_status = ::std::option::Option::None;
1131    }
1132
1133    pub fn has_recovery_status(&self) -> bool {
1134        self.recovery_status.is_some()
1135    }
1136
1137    // Param is passed by value, moved
1138    pub fn set_recovery_status(&mut self, v: features::RecoveryStatus) {
1139        self.recovery_status = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1140    }
1141
1142    // optional .hw.trezor.messages.management.BackupType backup_type = 31;
1143
1144    pub fn backup_type(&self) -> BackupType {
1145        match self.backup_type {
1146            Some(e) => e.enum_value_or(BackupType::Bip39),
1147            None => BackupType::Bip39,
1148        }
1149    }
1150
1151    pub fn clear_backup_type(&mut self) {
1152        self.backup_type = ::std::option::Option::None;
1153    }
1154
1155    pub fn has_backup_type(&self) -> bool {
1156        self.backup_type.is_some()
1157    }
1158
1159    // Param is passed by value, moved
1160    pub fn set_backup_type(&mut self, v: BackupType) {
1161        self.backup_type = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1162    }
1163
1164    // optional bool sd_card_present = 32;
1165
1166    pub fn sd_card_present(&self) -> bool {
1167        self.sd_card_present.unwrap_or(false)
1168    }
1169
1170    pub fn clear_sd_card_present(&mut self) {
1171        self.sd_card_present = ::std::option::Option::None;
1172    }
1173
1174    pub fn has_sd_card_present(&self) -> bool {
1175        self.sd_card_present.is_some()
1176    }
1177
1178    // Param is passed by value, moved
1179    pub fn set_sd_card_present(&mut self, v: bool) {
1180        self.sd_card_present = ::std::option::Option::Some(v);
1181    }
1182
1183    // optional bool sd_protection = 33;
1184
1185    pub fn sd_protection(&self) -> bool {
1186        self.sd_protection.unwrap_or(false)
1187    }
1188
1189    pub fn clear_sd_protection(&mut self) {
1190        self.sd_protection = ::std::option::Option::None;
1191    }
1192
1193    pub fn has_sd_protection(&self) -> bool {
1194        self.sd_protection.is_some()
1195    }
1196
1197    // Param is passed by value, moved
1198    pub fn set_sd_protection(&mut self, v: bool) {
1199        self.sd_protection = ::std::option::Option::Some(v);
1200    }
1201
1202    // optional bool wipe_code_protection = 34;
1203
1204    pub fn wipe_code_protection(&self) -> bool {
1205        self.wipe_code_protection.unwrap_or(false)
1206    }
1207
1208    pub fn clear_wipe_code_protection(&mut self) {
1209        self.wipe_code_protection = ::std::option::Option::None;
1210    }
1211
1212    pub fn has_wipe_code_protection(&self) -> bool {
1213        self.wipe_code_protection.is_some()
1214    }
1215
1216    // Param is passed by value, moved
1217    pub fn set_wipe_code_protection(&mut self, v: bool) {
1218        self.wipe_code_protection = ::std::option::Option::Some(v);
1219    }
1220
1221    // optional bytes session_id = 35;
1222
1223    pub fn session_id(&self) -> &[u8] {
1224        match self.session_id.as_ref() {
1225            Some(v) => v,
1226            None => &[],
1227        }
1228    }
1229
1230    pub fn clear_session_id(&mut self) {
1231        self.session_id = ::std::option::Option::None;
1232    }
1233
1234    pub fn has_session_id(&self) -> bool {
1235        self.session_id.is_some()
1236    }
1237
1238    // Param is passed by value, moved
1239    pub fn set_session_id(&mut self, v: ::std::vec::Vec<u8>) {
1240        self.session_id = ::std::option::Option::Some(v);
1241    }
1242
1243    // Mutable pointer to the field.
1244    // If field is not initialized, it is initialized with default value first.
1245    pub fn mut_session_id(&mut self) -> &mut ::std::vec::Vec<u8> {
1246        if self.session_id.is_none() {
1247            self.session_id = ::std::option::Option::Some(::std::vec::Vec::new());
1248        }
1249        self.session_id.as_mut().unwrap()
1250    }
1251
1252    // Take field
1253    pub fn take_session_id(&mut self) -> ::std::vec::Vec<u8> {
1254        self.session_id.take().unwrap_or_else(|| ::std::vec::Vec::new())
1255    }
1256
1257    // optional bool passphrase_always_on_device = 36;
1258
1259    pub fn passphrase_always_on_device(&self) -> bool {
1260        self.passphrase_always_on_device.unwrap_or(false)
1261    }
1262
1263    pub fn clear_passphrase_always_on_device(&mut self) {
1264        self.passphrase_always_on_device = ::std::option::Option::None;
1265    }
1266
1267    pub fn has_passphrase_always_on_device(&self) -> bool {
1268        self.passphrase_always_on_device.is_some()
1269    }
1270
1271    // Param is passed by value, moved
1272    pub fn set_passphrase_always_on_device(&mut self, v: bool) {
1273        self.passphrase_always_on_device = ::std::option::Option::Some(v);
1274    }
1275
1276    // optional .hw.trezor.messages.management.SafetyCheckLevel safety_checks = 37;
1277
1278    pub fn safety_checks(&self) -> SafetyCheckLevel {
1279        match self.safety_checks {
1280            Some(e) => e.enum_value_or(SafetyCheckLevel::Strict),
1281            None => SafetyCheckLevel::Strict,
1282        }
1283    }
1284
1285    pub fn clear_safety_checks(&mut self) {
1286        self.safety_checks = ::std::option::Option::None;
1287    }
1288
1289    pub fn has_safety_checks(&self) -> bool {
1290        self.safety_checks.is_some()
1291    }
1292
1293    // Param is passed by value, moved
1294    pub fn set_safety_checks(&mut self, v: SafetyCheckLevel) {
1295        self.safety_checks = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1296    }
1297
1298    // optional uint32 auto_lock_delay_ms = 38;
1299
1300    pub fn auto_lock_delay_ms(&self) -> u32 {
1301        self.auto_lock_delay_ms.unwrap_or(0)
1302    }
1303
1304    pub fn clear_auto_lock_delay_ms(&mut self) {
1305        self.auto_lock_delay_ms = ::std::option::Option::None;
1306    }
1307
1308    pub fn has_auto_lock_delay_ms(&self) -> bool {
1309        self.auto_lock_delay_ms.is_some()
1310    }
1311
1312    // Param is passed by value, moved
1313    pub fn set_auto_lock_delay_ms(&mut self, v: u32) {
1314        self.auto_lock_delay_ms = ::std::option::Option::Some(v);
1315    }
1316
1317    // optional uint32 display_rotation = 39;
1318
1319    pub fn display_rotation(&self) -> u32 {
1320        self.display_rotation.unwrap_or(0)
1321    }
1322
1323    pub fn clear_display_rotation(&mut self) {
1324        self.display_rotation = ::std::option::Option::None;
1325    }
1326
1327    pub fn has_display_rotation(&self) -> bool {
1328        self.display_rotation.is_some()
1329    }
1330
1331    // Param is passed by value, moved
1332    pub fn set_display_rotation(&mut self, v: u32) {
1333        self.display_rotation = ::std::option::Option::Some(v);
1334    }
1335
1336    // optional bool experimental_features = 40;
1337
1338    pub fn experimental_features(&self) -> bool {
1339        self.experimental_features.unwrap_or(false)
1340    }
1341
1342    pub fn clear_experimental_features(&mut self) {
1343        self.experimental_features = ::std::option::Option::None;
1344    }
1345
1346    pub fn has_experimental_features(&self) -> bool {
1347        self.experimental_features.is_some()
1348    }
1349
1350    // Param is passed by value, moved
1351    pub fn set_experimental_features(&mut self, v: bool) {
1352        self.experimental_features = ::std::option::Option::Some(v);
1353    }
1354
1355    // optional bool busy = 41;
1356
1357    pub fn busy(&self) -> bool {
1358        self.busy.unwrap_or(false)
1359    }
1360
1361    pub fn clear_busy(&mut self) {
1362        self.busy = ::std::option::Option::None;
1363    }
1364
1365    pub fn has_busy(&self) -> bool {
1366        self.busy.is_some()
1367    }
1368
1369    // Param is passed by value, moved
1370    pub fn set_busy(&mut self, v: bool) {
1371        self.busy = ::std::option::Option::Some(v);
1372    }
1373
1374    // optional .hw.trezor.messages.management.HomescreenFormat homescreen_format = 42;
1375
1376    pub fn homescreen_format(&self) -> HomescreenFormat {
1377        match self.homescreen_format {
1378            Some(e) => e.enum_value_or(HomescreenFormat::Toif),
1379            None => HomescreenFormat::Toif,
1380        }
1381    }
1382
1383    pub fn clear_homescreen_format(&mut self) {
1384        self.homescreen_format = ::std::option::Option::None;
1385    }
1386
1387    pub fn has_homescreen_format(&self) -> bool {
1388        self.homescreen_format.is_some()
1389    }
1390
1391    // Param is passed by value, moved
1392    pub fn set_homescreen_format(&mut self, v: HomescreenFormat) {
1393        self.homescreen_format = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1394    }
1395
1396    // optional bool hide_passphrase_from_host = 43;
1397
1398    pub fn hide_passphrase_from_host(&self) -> bool {
1399        self.hide_passphrase_from_host.unwrap_or(false)
1400    }
1401
1402    pub fn clear_hide_passphrase_from_host(&mut self) {
1403        self.hide_passphrase_from_host = ::std::option::Option::None;
1404    }
1405
1406    pub fn has_hide_passphrase_from_host(&self) -> bool {
1407        self.hide_passphrase_from_host.is_some()
1408    }
1409
1410    // Param is passed by value, moved
1411    pub fn set_hide_passphrase_from_host(&mut self, v: bool) {
1412        self.hide_passphrase_from_host = ::std::option::Option::Some(v);
1413    }
1414
1415    // optional string internal_model = 44;
1416
1417    pub fn internal_model(&self) -> &str {
1418        match self.internal_model.as_ref() {
1419            Some(v) => v,
1420            None => "",
1421        }
1422    }
1423
1424    pub fn clear_internal_model(&mut self) {
1425        self.internal_model = ::std::option::Option::None;
1426    }
1427
1428    pub fn has_internal_model(&self) -> bool {
1429        self.internal_model.is_some()
1430    }
1431
1432    // Param is passed by value, moved
1433    pub fn set_internal_model(&mut self, v: ::std::string::String) {
1434        self.internal_model = ::std::option::Option::Some(v);
1435    }
1436
1437    // Mutable pointer to the field.
1438    // If field is not initialized, it is initialized with default value first.
1439    pub fn mut_internal_model(&mut self) -> &mut ::std::string::String {
1440        if self.internal_model.is_none() {
1441            self.internal_model = ::std::option::Option::Some(::std::string::String::new());
1442        }
1443        self.internal_model.as_mut().unwrap()
1444    }
1445
1446    // Take field
1447    pub fn take_internal_model(&mut self) -> ::std::string::String {
1448        self.internal_model.take().unwrap_or_else(|| ::std::string::String::new())
1449    }
1450
1451    // optional uint32 unit_color = 45;
1452
1453    pub fn unit_color(&self) -> u32 {
1454        self.unit_color.unwrap_or(0)
1455    }
1456
1457    pub fn clear_unit_color(&mut self) {
1458        self.unit_color = ::std::option::Option::None;
1459    }
1460
1461    pub fn has_unit_color(&self) -> bool {
1462        self.unit_color.is_some()
1463    }
1464
1465    // Param is passed by value, moved
1466    pub fn set_unit_color(&mut self, v: u32) {
1467        self.unit_color = ::std::option::Option::Some(v);
1468    }
1469
1470    // optional bool unit_btconly = 46;
1471
1472    pub fn unit_btconly(&self) -> bool {
1473        self.unit_btconly.unwrap_or(false)
1474    }
1475
1476    pub fn clear_unit_btconly(&mut self) {
1477        self.unit_btconly = ::std::option::Option::None;
1478    }
1479
1480    pub fn has_unit_btconly(&self) -> bool {
1481        self.unit_btconly.is_some()
1482    }
1483
1484    // Param is passed by value, moved
1485    pub fn set_unit_btconly(&mut self, v: bool) {
1486        self.unit_btconly = ::std::option::Option::Some(v);
1487    }
1488
1489    // optional uint32 homescreen_width = 47;
1490
1491    pub fn homescreen_width(&self) -> u32 {
1492        self.homescreen_width.unwrap_or(0)
1493    }
1494
1495    pub fn clear_homescreen_width(&mut self) {
1496        self.homescreen_width = ::std::option::Option::None;
1497    }
1498
1499    pub fn has_homescreen_width(&self) -> bool {
1500        self.homescreen_width.is_some()
1501    }
1502
1503    // Param is passed by value, moved
1504    pub fn set_homescreen_width(&mut self, v: u32) {
1505        self.homescreen_width = ::std::option::Option::Some(v);
1506    }
1507
1508    // optional uint32 homescreen_height = 48;
1509
1510    pub fn homescreen_height(&self) -> u32 {
1511        self.homescreen_height.unwrap_or(0)
1512    }
1513
1514    pub fn clear_homescreen_height(&mut self) {
1515        self.homescreen_height = ::std::option::Option::None;
1516    }
1517
1518    pub fn has_homescreen_height(&self) -> bool {
1519        self.homescreen_height.is_some()
1520    }
1521
1522    // Param is passed by value, moved
1523    pub fn set_homescreen_height(&mut self, v: u32) {
1524        self.homescreen_height = ::std::option::Option::Some(v);
1525    }
1526
1527    // optional bool bootloader_locked = 49;
1528
1529    pub fn bootloader_locked(&self) -> bool {
1530        self.bootloader_locked.unwrap_or(false)
1531    }
1532
1533    pub fn clear_bootloader_locked(&mut self) {
1534        self.bootloader_locked = ::std::option::Option::None;
1535    }
1536
1537    pub fn has_bootloader_locked(&self) -> bool {
1538        self.bootloader_locked.is_some()
1539    }
1540
1541    // Param is passed by value, moved
1542    pub fn set_bootloader_locked(&mut self, v: bool) {
1543        self.bootloader_locked = ::std::option::Option::Some(v);
1544    }
1545
1546    // optional bool language_version_matches = 50;
1547
1548    pub fn language_version_matches(&self) -> bool {
1549        self.language_version_matches.unwrap_or(true)
1550    }
1551
1552    pub fn clear_language_version_matches(&mut self) {
1553        self.language_version_matches = ::std::option::Option::None;
1554    }
1555
1556    pub fn has_language_version_matches(&self) -> bool {
1557        self.language_version_matches.is_some()
1558    }
1559
1560    // Param is passed by value, moved
1561    pub fn set_language_version_matches(&mut self, v: bool) {
1562        self.language_version_matches = ::std::option::Option::Some(v);
1563    }
1564
1565    // optional uint32 unit_packaging = 51;
1566
1567    pub fn unit_packaging(&self) -> u32 {
1568        self.unit_packaging.unwrap_or(0)
1569    }
1570
1571    pub fn clear_unit_packaging(&mut self) {
1572        self.unit_packaging = ::std::option::Option::None;
1573    }
1574
1575    pub fn has_unit_packaging(&self) -> bool {
1576        self.unit_packaging.is_some()
1577    }
1578
1579    // Param is passed by value, moved
1580    pub fn set_unit_packaging(&mut self, v: u32) {
1581        self.unit_packaging = ::std::option::Option::Some(v);
1582    }
1583
1584    // optional bool haptic_feedback = 52;
1585
1586    pub fn haptic_feedback(&self) -> bool {
1587        self.haptic_feedback.unwrap_or(false)
1588    }
1589
1590    pub fn clear_haptic_feedback(&mut self) {
1591        self.haptic_feedback = ::std::option::Option::None;
1592    }
1593
1594    pub fn has_haptic_feedback(&self) -> bool {
1595        self.haptic_feedback.is_some()
1596    }
1597
1598    // Param is passed by value, moved
1599    pub fn set_haptic_feedback(&mut self, v: bool) {
1600        self.haptic_feedback = ::std::option::Option::Some(v);
1601    }
1602
1603    // optional .hw.trezor.messages.management.RecoveryType recovery_type = 53;
1604
1605    pub fn recovery_type(&self) -> RecoveryType {
1606        match self.recovery_type {
1607            Some(e) => e.enum_value_or(RecoveryType::NormalRecovery),
1608            None => RecoveryType::NormalRecovery,
1609        }
1610    }
1611
1612    pub fn clear_recovery_type(&mut self) {
1613        self.recovery_type = ::std::option::Option::None;
1614    }
1615
1616    pub fn has_recovery_type(&self) -> bool {
1617        self.recovery_type.is_some()
1618    }
1619
1620    // Param is passed by value, moved
1621    pub fn set_recovery_type(&mut self, v: RecoveryType) {
1622        self.recovery_type = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1623    }
1624
1625    // optional uint32 optiga_sec = 54;
1626
1627    pub fn optiga_sec(&self) -> u32 {
1628        self.optiga_sec.unwrap_or(0)
1629    }
1630
1631    pub fn clear_optiga_sec(&mut self) {
1632        self.optiga_sec = ::std::option::Option::None;
1633    }
1634
1635    pub fn has_optiga_sec(&self) -> bool {
1636        self.optiga_sec.is_some()
1637    }
1638
1639    // Param is passed by value, moved
1640    pub fn set_optiga_sec(&mut self, v: u32) {
1641        self.optiga_sec = ::std::option::Option::Some(v);
1642    }
1643
1644    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1645        let mut fields = ::std::vec::Vec::with_capacity(52);
1646        let mut oneofs = ::std::vec::Vec::with_capacity(0);
1647        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1648            "vendor",
1649            |m: &Features| { &m.vendor },
1650            |m: &mut Features| { &mut m.vendor },
1651        ));
1652        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1653            "major_version",
1654            |m: &Features| { &m.major_version },
1655            |m: &mut Features| { &mut m.major_version },
1656        ));
1657        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1658            "minor_version",
1659            |m: &Features| { &m.minor_version },
1660            |m: &mut Features| { &mut m.minor_version },
1661        ));
1662        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1663            "patch_version",
1664            |m: &Features| { &m.patch_version },
1665            |m: &mut Features| { &mut m.patch_version },
1666        ));
1667        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1668            "bootloader_mode",
1669            |m: &Features| { &m.bootloader_mode },
1670            |m: &mut Features| { &mut m.bootloader_mode },
1671        ));
1672        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1673            "device_id",
1674            |m: &Features| { &m.device_id },
1675            |m: &mut Features| { &mut m.device_id },
1676        ));
1677        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1678            "pin_protection",
1679            |m: &Features| { &m.pin_protection },
1680            |m: &mut Features| { &mut m.pin_protection },
1681        ));
1682        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1683            "passphrase_protection",
1684            |m: &Features| { &m.passphrase_protection },
1685            |m: &mut Features| { &mut m.passphrase_protection },
1686        ));
1687        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1688            "language",
1689            |m: &Features| { &m.language },
1690            |m: &mut Features| { &mut m.language },
1691        ));
1692        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1693            "label",
1694            |m: &Features| { &m.label },
1695            |m: &mut Features| { &mut m.label },
1696        ));
1697        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1698            "initialized",
1699            |m: &Features| { &m.initialized },
1700            |m: &mut Features| { &mut m.initialized },
1701        ));
1702        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1703            "revision",
1704            |m: &Features| { &m.revision },
1705            |m: &mut Features| { &mut m.revision },
1706        ));
1707        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1708            "bootloader_hash",
1709            |m: &Features| { &m.bootloader_hash },
1710            |m: &mut Features| { &mut m.bootloader_hash },
1711        ));
1712        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1713            "imported",
1714            |m: &Features| { &m.imported },
1715            |m: &mut Features| { &mut m.imported },
1716        ));
1717        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1718            "unlocked",
1719            |m: &Features| { &m.unlocked },
1720            |m: &mut Features| { &mut m.unlocked },
1721        ));
1722        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1723            "_passphrase_cached",
1724            |m: &Features| { &m._passphrase_cached },
1725            |m: &mut Features| { &mut m._passphrase_cached },
1726        ));
1727        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1728            "firmware_present",
1729            |m: &Features| { &m.firmware_present },
1730            |m: &mut Features| { &mut m.firmware_present },
1731        ));
1732        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1733            "backup_availability",
1734            |m: &Features| { &m.backup_availability },
1735            |m: &mut Features| { &mut m.backup_availability },
1736        ));
1737        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1738            "flags",
1739            |m: &Features| { &m.flags },
1740            |m: &mut Features| { &mut m.flags },
1741        ));
1742        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1743            "model",
1744            |m: &Features| { &m.model },
1745            |m: &mut Features| { &mut m.model },
1746        ));
1747        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1748            "fw_major",
1749            |m: &Features| { &m.fw_major },
1750            |m: &mut Features| { &mut m.fw_major },
1751        ));
1752        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1753            "fw_minor",
1754            |m: &Features| { &m.fw_minor },
1755            |m: &mut Features| { &mut m.fw_minor },
1756        ));
1757        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1758            "fw_patch",
1759            |m: &Features| { &m.fw_patch },
1760            |m: &mut Features| { &mut m.fw_patch },
1761        ));
1762        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1763            "fw_vendor",
1764            |m: &Features| { &m.fw_vendor },
1765            |m: &mut Features| { &mut m.fw_vendor },
1766        ));
1767        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1768            "unfinished_backup",
1769            |m: &Features| { &m.unfinished_backup },
1770            |m: &mut Features| { &mut m.unfinished_backup },
1771        ));
1772        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1773            "no_backup",
1774            |m: &Features| { &m.no_backup },
1775            |m: &mut Features| { &mut m.no_backup },
1776        ));
1777        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1778            "recovery_status",
1779            |m: &Features| { &m.recovery_status },
1780            |m: &mut Features| { &mut m.recovery_status },
1781        ));
1782        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
1783            "capabilities",
1784            |m: &Features| { &m.capabilities },
1785            |m: &mut Features| { &mut m.capabilities },
1786        ));
1787        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1788            "backup_type",
1789            |m: &Features| { &m.backup_type },
1790            |m: &mut Features| { &mut m.backup_type },
1791        ));
1792        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1793            "sd_card_present",
1794            |m: &Features| { &m.sd_card_present },
1795            |m: &mut Features| { &mut m.sd_card_present },
1796        ));
1797        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1798            "sd_protection",
1799            |m: &Features| { &m.sd_protection },
1800            |m: &mut Features| { &mut m.sd_protection },
1801        ));
1802        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1803            "wipe_code_protection",
1804            |m: &Features| { &m.wipe_code_protection },
1805            |m: &mut Features| { &mut m.wipe_code_protection },
1806        ));
1807        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1808            "session_id",
1809            |m: &Features| { &m.session_id },
1810            |m: &mut Features| { &mut m.session_id },
1811        ));
1812        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1813            "passphrase_always_on_device",
1814            |m: &Features| { &m.passphrase_always_on_device },
1815            |m: &mut Features| { &mut m.passphrase_always_on_device },
1816        ));
1817        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1818            "safety_checks",
1819            |m: &Features| { &m.safety_checks },
1820            |m: &mut Features| { &mut m.safety_checks },
1821        ));
1822        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1823            "auto_lock_delay_ms",
1824            |m: &Features| { &m.auto_lock_delay_ms },
1825            |m: &mut Features| { &mut m.auto_lock_delay_ms },
1826        ));
1827        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1828            "display_rotation",
1829            |m: &Features| { &m.display_rotation },
1830            |m: &mut Features| { &mut m.display_rotation },
1831        ));
1832        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1833            "experimental_features",
1834            |m: &Features| { &m.experimental_features },
1835            |m: &mut Features| { &mut m.experimental_features },
1836        ));
1837        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1838            "busy",
1839            |m: &Features| { &m.busy },
1840            |m: &mut Features| { &mut m.busy },
1841        ));
1842        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1843            "homescreen_format",
1844            |m: &Features| { &m.homescreen_format },
1845            |m: &mut Features| { &mut m.homescreen_format },
1846        ));
1847        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1848            "hide_passphrase_from_host",
1849            |m: &Features| { &m.hide_passphrase_from_host },
1850            |m: &mut Features| { &mut m.hide_passphrase_from_host },
1851        ));
1852        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1853            "internal_model",
1854            |m: &Features| { &m.internal_model },
1855            |m: &mut Features| { &mut m.internal_model },
1856        ));
1857        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1858            "unit_color",
1859            |m: &Features| { &m.unit_color },
1860            |m: &mut Features| { &mut m.unit_color },
1861        ));
1862        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1863            "unit_btconly",
1864            |m: &Features| { &m.unit_btconly },
1865            |m: &mut Features| { &mut m.unit_btconly },
1866        ));
1867        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1868            "homescreen_width",
1869            |m: &Features| { &m.homescreen_width },
1870            |m: &mut Features| { &mut m.homescreen_width },
1871        ));
1872        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1873            "homescreen_height",
1874            |m: &Features| { &m.homescreen_height },
1875            |m: &mut Features| { &mut m.homescreen_height },
1876        ));
1877        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1878            "bootloader_locked",
1879            |m: &Features| { &m.bootloader_locked },
1880            |m: &mut Features| { &mut m.bootloader_locked },
1881        ));
1882        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1883            "language_version_matches",
1884            |m: &Features| { &m.language_version_matches },
1885            |m: &mut Features| { &mut m.language_version_matches },
1886        ));
1887        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1888            "unit_packaging",
1889            |m: &Features| { &m.unit_packaging },
1890            |m: &mut Features| { &mut m.unit_packaging },
1891        ));
1892        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1893            "haptic_feedback",
1894            |m: &Features| { &m.haptic_feedback },
1895            |m: &mut Features| { &mut m.haptic_feedback },
1896        ));
1897        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1898            "recovery_type",
1899            |m: &Features| { &m.recovery_type },
1900            |m: &mut Features| { &mut m.recovery_type },
1901        ));
1902        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1903            "optiga_sec",
1904            |m: &Features| { &m.optiga_sec },
1905            |m: &mut Features| { &mut m.optiga_sec },
1906        ));
1907        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Features>(
1908            "Features",
1909            fields,
1910            oneofs,
1911        )
1912    }
1913}
1914
1915impl ::protobuf::Message for Features {
1916    const NAME: &'static str = "Features";
1917
1918    fn is_initialized(&self) -> bool {
1919        if self.major_version.is_none() {
1920            return false;
1921        }
1922        if self.minor_version.is_none() {
1923            return false;
1924        }
1925        if self.patch_version.is_none() {
1926            return false;
1927        }
1928        true
1929    }
1930
1931    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1932        while let Some(tag) = is.read_raw_tag_or_eof()? {
1933            match tag {
1934                10 => {
1935                    self.vendor = ::std::option::Option::Some(is.read_string()?);
1936                },
1937                16 => {
1938                    self.major_version = ::std::option::Option::Some(is.read_uint32()?);
1939                },
1940                24 => {
1941                    self.minor_version = ::std::option::Option::Some(is.read_uint32()?);
1942                },
1943                32 => {
1944                    self.patch_version = ::std::option::Option::Some(is.read_uint32()?);
1945                },
1946                40 => {
1947                    self.bootloader_mode = ::std::option::Option::Some(is.read_bool()?);
1948                },
1949                50 => {
1950                    self.device_id = ::std::option::Option::Some(is.read_string()?);
1951                },
1952                56 => {
1953                    self.pin_protection = ::std::option::Option::Some(is.read_bool()?);
1954                },
1955                64 => {
1956                    self.passphrase_protection = ::std::option::Option::Some(is.read_bool()?);
1957                },
1958                74 => {
1959                    self.language = ::std::option::Option::Some(is.read_string()?);
1960                },
1961                82 => {
1962                    self.label = ::std::option::Option::Some(is.read_string()?);
1963                },
1964                96 => {
1965                    self.initialized = ::std::option::Option::Some(is.read_bool()?);
1966                },
1967                106 => {
1968                    self.revision = ::std::option::Option::Some(is.read_bytes()?);
1969                },
1970                114 => {
1971                    self.bootloader_hash = ::std::option::Option::Some(is.read_bytes()?);
1972                },
1973                120 => {
1974                    self.imported = ::std::option::Option::Some(is.read_bool()?);
1975                },
1976                128 => {
1977                    self.unlocked = ::std::option::Option::Some(is.read_bool()?);
1978                },
1979                136 => {
1980                    self._passphrase_cached = ::std::option::Option::Some(is.read_bool()?);
1981                },
1982                144 => {
1983                    self.firmware_present = ::std::option::Option::Some(is.read_bool()?);
1984                },
1985                152 => {
1986                    self.backup_availability = ::std::option::Option::Some(is.read_enum_or_unknown()?);
1987                },
1988                160 => {
1989                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
1990                },
1991                170 => {
1992                    self.model = ::std::option::Option::Some(is.read_string()?);
1993                },
1994                176 => {
1995                    self.fw_major = ::std::option::Option::Some(is.read_uint32()?);
1996                },
1997                184 => {
1998                    self.fw_minor = ::std::option::Option::Some(is.read_uint32()?);
1999                },
2000                192 => {
2001                    self.fw_patch = ::std::option::Option::Some(is.read_uint32()?);
2002                },
2003                202 => {
2004                    self.fw_vendor = ::std::option::Option::Some(is.read_string()?);
2005                },
2006                216 => {
2007                    self.unfinished_backup = ::std::option::Option::Some(is.read_bool()?);
2008                },
2009                224 => {
2010                    self.no_backup = ::std::option::Option::Some(is.read_bool()?);
2011                },
2012                232 => {
2013                    self.recovery_status = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2014                },
2015                240 => {
2016                    self.capabilities.push(is.read_enum_or_unknown()?);
2017                },
2018                242 => {
2019                    ::protobuf::rt::read_repeated_packed_enum_or_unknown_into(is, &mut self.capabilities)?
2020                },
2021                248 => {
2022                    self.backup_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2023                },
2024                256 => {
2025                    self.sd_card_present = ::std::option::Option::Some(is.read_bool()?);
2026                },
2027                264 => {
2028                    self.sd_protection = ::std::option::Option::Some(is.read_bool()?);
2029                },
2030                272 => {
2031                    self.wipe_code_protection = ::std::option::Option::Some(is.read_bool()?);
2032                },
2033                282 => {
2034                    self.session_id = ::std::option::Option::Some(is.read_bytes()?);
2035                },
2036                288 => {
2037                    self.passphrase_always_on_device = ::std::option::Option::Some(is.read_bool()?);
2038                },
2039                296 => {
2040                    self.safety_checks = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2041                },
2042                304 => {
2043                    self.auto_lock_delay_ms = ::std::option::Option::Some(is.read_uint32()?);
2044                },
2045                312 => {
2046                    self.display_rotation = ::std::option::Option::Some(is.read_uint32()?);
2047                },
2048                320 => {
2049                    self.experimental_features = ::std::option::Option::Some(is.read_bool()?);
2050                },
2051                328 => {
2052                    self.busy = ::std::option::Option::Some(is.read_bool()?);
2053                },
2054                336 => {
2055                    self.homescreen_format = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2056                },
2057                344 => {
2058                    self.hide_passphrase_from_host = ::std::option::Option::Some(is.read_bool()?);
2059                },
2060                354 => {
2061                    self.internal_model = ::std::option::Option::Some(is.read_string()?);
2062                },
2063                360 => {
2064                    self.unit_color = ::std::option::Option::Some(is.read_uint32()?);
2065                },
2066                368 => {
2067                    self.unit_btconly = ::std::option::Option::Some(is.read_bool()?);
2068                },
2069                376 => {
2070                    self.homescreen_width = ::std::option::Option::Some(is.read_uint32()?);
2071                },
2072                384 => {
2073                    self.homescreen_height = ::std::option::Option::Some(is.read_uint32()?);
2074                },
2075                392 => {
2076                    self.bootloader_locked = ::std::option::Option::Some(is.read_bool()?);
2077                },
2078                400 => {
2079                    self.language_version_matches = ::std::option::Option::Some(is.read_bool()?);
2080                },
2081                408 => {
2082                    self.unit_packaging = ::std::option::Option::Some(is.read_uint32()?);
2083                },
2084                416 => {
2085                    self.haptic_feedback = ::std::option::Option::Some(is.read_bool()?);
2086                },
2087                424 => {
2088                    self.recovery_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
2089                },
2090                432 => {
2091                    self.optiga_sec = ::std::option::Option::Some(is.read_uint32()?);
2092                },
2093                tag => {
2094                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2095                },
2096            };
2097        }
2098        ::std::result::Result::Ok(())
2099    }
2100
2101    // Compute sizes of nested messages
2102    #[allow(unused_variables)]
2103    fn compute_size(&self) -> u64 {
2104        let mut my_size = 0;
2105        if let Some(v) = self.vendor.as_ref() {
2106            my_size += ::protobuf::rt::string_size(1, &v);
2107        }
2108        if let Some(v) = self.major_version {
2109            my_size += ::protobuf::rt::uint32_size(2, v);
2110        }
2111        if let Some(v) = self.minor_version {
2112            my_size += ::protobuf::rt::uint32_size(3, v);
2113        }
2114        if let Some(v) = self.patch_version {
2115            my_size += ::protobuf::rt::uint32_size(4, v);
2116        }
2117        if let Some(v) = self.bootloader_mode {
2118            my_size += 1 + 1;
2119        }
2120        if let Some(v) = self.device_id.as_ref() {
2121            my_size += ::protobuf::rt::string_size(6, &v);
2122        }
2123        if let Some(v) = self.pin_protection {
2124            my_size += 1 + 1;
2125        }
2126        if let Some(v) = self.passphrase_protection {
2127            my_size += 1 + 1;
2128        }
2129        if let Some(v) = self.language.as_ref() {
2130            my_size += ::protobuf::rt::string_size(9, &v);
2131        }
2132        if let Some(v) = self.label.as_ref() {
2133            my_size += ::protobuf::rt::string_size(10, &v);
2134        }
2135        if let Some(v) = self.initialized {
2136            my_size += 1 + 1;
2137        }
2138        if let Some(v) = self.revision.as_ref() {
2139            my_size += ::protobuf::rt::bytes_size(13, &v);
2140        }
2141        if let Some(v) = self.bootloader_hash.as_ref() {
2142            my_size += ::protobuf::rt::bytes_size(14, &v);
2143        }
2144        if let Some(v) = self.imported {
2145            my_size += 1 + 1;
2146        }
2147        if let Some(v) = self.unlocked {
2148            my_size += 2 + 1;
2149        }
2150        if let Some(v) = self._passphrase_cached {
2151            my_size += 2 + 1;
2152        }
2153        if let Some(v) = self.firmware_present {
2154            my_size += 2 + 1;
2155        }
2156        if let Some(v) = self.backup_availability {
2157            my_size += ::protobuf::rt::int32_size(19, v.value());
2158        }
2159        if let Some(v) = self.flags {
2160            my_size += ::protobuf::rt::uint32_size(20, v);
2161        }
2162        if let Some(v) = self.model.as_ref() {
2163            my_size += ::protobuf::rt::string_size(21, &v);
2164        }
2165        if let Some(v) = self.fw_major {
2166            my_size += ::protobuf::rt::uint32_size(22, v);
2167        }
2168        if let Some(v) = self.fw_minor {
2169            my_size += ::protobuf::rt::uint32_size(23, v);
2170        }
2171        if let Some(v) = self.fw_patch {
2172            my_size += ::protobuf::rt::uint32_size(24, v);
2173        }
2174        if let Some(v) = self.fw_vendor.as_ref() {
2175            my_size += ::protobuf::rt::string_size(25, &v);
2176        }
2177        if let Some(v) = self.unfinished_backup {
2178            my_size += 2 + 1;
2179        }
2180        if let Some(v) = self.no_backup {
2181            my_size += 2 + 1;
2182        }
2183        if let Some(v) = self.recovery_status {
2184            my_size += ::protobuf::rt::int32_size(29, v.value());
2185        }
2186        for value in &self.capabilities {
2187            my_size += ::protobuf::rt::int32_size(30, value.value());
2188        };
2189        if let Some(v) = self.backup_type {
2190            my_size += ::protobuf::rt::int32_size(31, v.value());
2191        }
2192        if let Some(v) = self.sd_card_present {
2193            my_size += 2 + 1;
2194        }
2195        if let Some(v) = self.sd_protection {
2196            my_size += 2 + 1;
2197        }
2198        if let Some(v) = self.wipe_code_protection {
2199            my_size += 2 + 1;
2200        }
2201        if let Some(v) = self.session_id.as_ref() {
2202            my_size += ::protobuf::rt::bytes_size(35, &v);
2203        }
2204        if let Some(v) = self.passphrase_always_on_device {
2205            my_size += 2 + 1;
2206        }
2207        if let Some(v) = self.safety_checks {
2208            my_size += ::protobuf::rt::int32_size(37, v.value());
2209        }
2210        if let Some(v) = self.auto_lock_delay_ms {
2211            my_size += ::protobuf::rt::uint32_size(38, v);
2212        }
2213        if let Some(v) = self.display_rotation {
2214            my_size += ::protobuf::rt::uint32_size(39, v);
2215        }
2216        if let Some(v) = self.experimental_features {
2217            my_size += 2 + 1;
2218        }
2219        if let Some(v) = self.busy {
2220            my_size += 2 + 1;
2221        }
2222        if let Some(v) = self.homescreen_format {
2223            my_size += ::protobuf::rt::int32_size(42, v.value());
2224        }
2225        if let Some(v) = self.hide_passphrase_from_host {
2226            my_size += 2 + 1;
2227        }
2228        if let Some(v) = self.internal_model.as_ref() {
2229            my_size += ::protobuf::rt::string_size(44, &v);
2230        }
2231        if let Some(v) = self.unit_color {
2232            my_size += ::protobuf::rt::uint32_size(45, v);
2233        }
2234        if let Some(v) = self.unit_btconly {
2235            my_size += 2 + 1;
2236        }
2237        if let Some(v) = self.homescreen_width {
2238            my_size += ::protobuf::rt::uint32_size(47, v);
2239        }
2240        if let Some(v) = self.homescreen_height {
2241            my_size += ::protobuf::rt::uint32_size(48, v);
2242        }
2243        if let Some(v) = self.bootloader_locked {
2244            my_size += 2 + 1;
2245        }
2246        if let Some(v) = self.language_version_matches {
2247            my_size += 2 + 1;
2248        }
2249        if let Some(v) = self.unit_packaging {
2250            my_size += ::protobuf::rt::uint32_size(51, v);
2251        }
2252        if let Some(v) = self.haptic_feedback {
2253            my_size += 2 + 1;
2254        }
2255        if let Some(v) = self.recovery_type {
2256            my_size += ::protobuf::rt::int32_size(53, v.value());
2257        }
2258        if let Some(v) = self.optiga_sec {
2259            my_size += ::protobuf::rt::uint32_size(54, v);
2260        }
2261        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2262        self.special_fields.cached_size().set(my_size as u32);
2263        my_size
2264    }
2265
2266    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2267        if let Some(v) = self.vendor.as_ref() {
2268            os.write_string(1, v)?;
2269        }
2270        if let Some(v) = self.major_version {
2271            os.write_uint32(2, v)?;
2272        }
2273        if let Some(v) = self.minor_version {
2274            os.write_uint32(3, v)?;
2275        }
2276        if let Some(v) = self.patch_version {
2277            os.write_uint32(4, v)?;
2278        }
2279        if let Some(v) = self.bootloader_mode {
2280            os.write_bool(5, v)?;
2281        }
2282        if let Some(v) = self.device_id.as_ref() {
2283            os.write_string(6, v)?;
2284        }
2285        if let Some(v) = self.pin_protection {
2286            os.write_bool(7, v)?;
2287        }
2288        if let Some(v) = self.passphrase_protection {
2289            os.write_bool(8, v)?;
2290        }
2291        if let Some(v) = self.language.as_ref() {
2292            os.write_string(9, v)?;
2293        }
2294        if let Some(v) = self.label.as_ref() {
2295            os.write_string(10, v)?;
2296        }
2297        if let Some(v) = self.initialized {
2298            os.write_bool(12, v)?;
2299        }
2300        if let Some(v) = self.revision.as_ref() {
2301            os.write_bytes(13, v)?;
2302        }
2303        if let Some(v) = self.bootloader_hash.as_ref() {
2304            os.write_bytes(14, v)?;
2305        }
2306        if let Some(v) = self.imported {
2307            os.write_bool(15, v)?;
2308        }
2309        if let Some(v) = self.unlocked {
2310            os.write_bool(16, v)?;
2311        }
2312        if let Some(v) = self._passphrase_cached {
2313            os.write_bool(17, v)?;
2314        }
2315        if let Some(v) = self.firmware_present {
2316            os.write_bool(18, v)?;
2317        }
2318        if let Some(v) = self.backup_availability {
2319            os.write_enum(19, ::protobuf::EnumOrUnknown::value(&v))?;
2320        }
2321        if let Some(v) = self.flags {
2322            os.write_uint32(20, v)?;
2323        }
2324        if let Some(v) = self.model.as_ref() {
2325            os.write_string(21, v)?;
2326        }
2327        if let Some(v) = self.fw_major {
2328            os.write_uint32(22, v)?;
2329        }
2330        if let Some(v) = self.fw_minor {
2331            os.write_uint32(23, v)?;
2332        }
2333        if let Some(v) = self.fw_patch {
2334            os.write_uint32(24, v)?;
2335        }
2336        if let Some(v) = self.fw_vendor.as_ref() {
2337            os.write_string(25, v)?;
2338        }
2339        if let Some(v) = self.unfinished_backup {
2340            os.write_bool(27, v)?;
2341        }
2342        if let Some(v) = self.no_backup {
2343            os.write_bool(28, v)?;
2344        }
2345        if let Some(v) = self.recovery_status {
2346            os.write_enum(29, ::protobuf::EnumOrUnknown::value(&v))?;
2347        }
2348        for v in &self.capabilities {
2349            os.write_enum(30, ::protobuf::EnumOrUnknown::value(v))?;
2350        };
2351        if let Some(v) = self.backup_type {
2352            os.write_enum(31, ::protobuf::EnumOrUnknown::value(&v))?;
2353        }
2354        if let Some(v) = self.sd_card_present {
2355            os.write_bool(32, v)?;
2356        }
2357        if let Some(v) = self.sd_protection {
2358            os.write_bool(33, v)?;
2359        }
2360        if let Some(v) = self.wipe_code_protection {
2361            os.write_bool(34, v)?;
2362        }
2363        if let Some(v) = self.session_id.as_ref() {
2364            os.write_bytes(35, v)?;
2365        }
2366        if let Some(v) = self.passphrase_always_on_device {
2367            os.write_bool(36, v)?;
2368        }
2369        if let Some(v) = self.safety_checks {
2370            os.write_enum(37, ::protobuf::EnumOrUnknown::value(&v))?;
2371        }
2372        if let Some(v) = self.auto_lock_delay_ms {
2373            os.write_uint32(38, v)?;
2374        }
2375        if let Some(v) = self.display_rotation {
2376            os.write_uint32(39, v)?;
2377        }
2378        if let Some(v) = self.experimental_features {
2379            os.write_bool(40, v)?;
2380        }
2381        if let Some(v) = self.busy {
2382            os.write_bool(41, v)?;
2383        }
2384        if let Some(v) = self.homescreen_format {
2385            os.write_enum(42, ::protobuf::EnumOrUnknown::value(&v))?;
2386        }
2387        if let Some(v) = self.hide_passphrase_from_host {
2388            os.write_bool(43, v)?;
2389        }
2390        if let Some(v) = self.internal_model.as_ref() {
2391            os.write_string(44, v)?;
2392        }
2393        if let Some(v) = self.unit_color {
2394            os.write_uint32(45, v)?;
2395        }
2396        if let Some(v) = self.unit_btconly {
2397            os.write_bool(46, v)?;
2398        }
2399        if let Some(v) = self.homescreen_width {
2400            os.write_uint32(47, v)?;
2401        }
2402        if let Some(v) = self.homescreen_height {
2403            os.write_uint32(48, v)?;
2404        }
2405        if let Some(v) = self.bootloader_locked {
2406            os.write_bool(49, v)?;
2407        }
2408        if let Some(v) = self.language_version_matches {
2409            os.write_bool(50, v)?;
2410        }
2411        if let Some(v) = self.unit_packaging {
2412            os.write_uint32(51, v)?;
2413        }
2414        if let Some(v) = self.haptic_feedback {
2415            os.write_bool(52, v)?;
2416        }
2417        if let Some(v) = self.recovery_type {
2418            os.write_enum(53, ::protobuf::EnumOrUnknown::value(&v))?;
2419        }
2420        if let Some(v) = self.optiga_sec {
2421            os.write_uint32(54, v)?;
2422        }
2423        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2424        ::std::result::Result::Ok(())
2425    }
2426
2427    fn special_fields(&self) -> &::protobuf::SpecialFields {
2428        &self.special_fields
2429    }
2430
2431    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2432        &mut self.special_fields
2433    }
2434
2435    fn new() -> Features {
2436        Features::new()
2437    }
2438
2439    fn clear(&mut self) {
2440        self.vendor = ::std::option::Option::None;
2441        self.major_version = ::std::option::Option::None;
2442        self.minor_version = ::std::option::Option::None;
2443        self.patch_version = ::std::option::Option::None;
2444        self.bootloader_mode = ::std::option::Option::None;
2445        self.device_id = ::std::option::Option::None;
2446        self.pin_protection = ::std::option::Option::None;
2447        self.passphrase_protection = ::std::option::Option::None;
2448        self.language = ::std::option::Option::None;
2449        self.label = ::std::option::Option::None;
2450        self.initialized = ::std::option::Option::None;
2451        self.revision = ::std::option::Option::None;
2452        self.bootloader_hash = ::std::option::Option::None;
2453        self.imported = ::std::option::Option::None;
2454        self.unlocked = ::std::option::Option::None;
2455        self._passphrase_cached = ::std::option::Option::None;
2456        self.firmware_present = ::std::option::Option::None;
2457        self.backup_availability = ::std::option::Option::None;
2458        self.flags = ::std::option::Option::None;
2459        self.model = ::std::option::Option::None;
2460        self.fw_major = ::std::option::Option::None;
2461        self.fw_minor = ::std::option::Option::None;
2462        self.fw_patch = ::std::option::Option::None;
2463        self.fw_vendor = ::std::option::Option::None;
2464        self.unfinished_backup = ::std::option::Option::None;
2465        self.no_backup = ::std::option::Option::None;
2466        self.recovery_status = ::std::option::Option::None;
2467        self.capabilities.clear();
2468        self.backup_type = ::std::option::Option::None;
2469        self.sd_card_present = ::std::option::Option::None;
2470        self.sd_protection = ::std::option::Option::None;
2471        self.wipe_code_protection = ::std::option::Option::None;
2472        self.session_id = ::std::option::Option::None;
2473        self.passphrase_always_on_device = ::std::option::Option::None;
2474        self.safety_checks = ::std::option::Option::None;
2475        self.auto_lock_delay_ms = ::std::option::Option::None;
2476        self.display_rotation = ::std::option::Option::None;
2477        self.experimental_features = ::std::option::Option::None;
2478        self.busy = ::std::option::Option::None;
2479        self.homescreen_format = ::std::option::Option::None;
2480        self.hide_passphrase_from_host = ::std::option::Option::None;
2481        self.internal_model = ::std::option::Option::None;
2482        self.unit_color = ::std::option::Option::None;
2483        self.unit_btconly = ::std::option::Option::None;
2484        self.homescreen_width = ::std::option::Option::None;
2485        self.homescreen_height = ::std::option::Option::None;
2486        self.bootloader_locked = ::std::option::Option::None;
2487        self.language_version_matches = ::std::option::Option::None;
2488        self.unit_packaging = ::std::option::Option::None;
2489        self.haptic_feedback = ::std::option::Option::None;
2490        self.recovery_type = ::std::option::Option::None;
2491        self.optiga_sec = ::std::option::Option::None;
2492        self.special_fields.clear();
2493    }
2494
2495    fn default_instance() -> &'static Features {
2496        static instance: Features = Features {
2497            vendor: ::std::option::Option::None,
2498            major_version: ::std::option::Option::None,
2499            minor_version: ::std::option::Option::None,
2500            patch_version: ::std::option::Option::None,
2501            bootloader_mode: ::std::option::Option::None,
2502            device_id: ::std::option::Option::None,
2503            pin_protection: ::std::option::Option::None,
2504            passphrase_protection: ::std::option::Option::None,
2505            language: ::std::option::Option::None,
2506            label: ::std::option::Option::None,
2507            initialized: ::std::option::Option::None,
2508            revision: ::std::option::Option::None,
2509            bootloader_hash: ::std::option::Option::None,
2510            imported: ::std::option::Option::None,
2511            unlocked: ::std::option::Option::None,
2512            _passphrase_cached: ::std::option::Option::None,
2513            firmware_present: ::std::option::Option::None,
2514            backup_availability: ::std::option::Option::None,
2515            flags: ::std::option::Option::None,
2516            model: ::std::option::Option::None,
2517            fw_major: ::std::option::Option::None,
2518            fw_minor: ::std::option::Option::None,
2519            fw_patch: ::std::option::Option::None,
2520            fw_vendor: ::std::option::Option::None,
2521            unfinished_backup: ::std::option::Option::None,
2522            no_backup: ::std::option::Option::None,
2523            recovery_status: ::std::option::Option::None,
2524            capabilities: ::std::vec::Vec::new(),
2525            backup_type: ::std::option::Option::None,
2526            sd_card_present: ::std::option::Option::None,
2527            sd_protection: ::std::option::Option::None,
2528            wipe_code_protection: ::std::option::Option::None,
2529            session_id: ::std::option::Option::None,
2530            passphrase_always_on_device: ::std::option::Option::None,
2531            safety_checks: ::std::option::Option::None,
2532            auto_lock_delay_ms: ::std::option::Option::None,
2533            display_rotation: ::std::option::Option::None,
2534            experimental_features: ::std::option::Option::None,
2535            busy: ::std::option::Option::None,
2536            homescreen_format: ::std::option::Option::None,
2537            hide_passphrase_from_host: ::std::option::Option::None,
2538            internal_model: ::std::option::Option::None,
2539            unit_color: ::std::option::Option::None,
2540            unit_btconly: ::std::option::Option::None,
2541            homescreen_width: ::std::option::Option::None,
2542            homescreen_height: ::std::option::Option::None,
2543            bootloader_locked: ::std::option::Option::None,
2544            language_version_matches: ::std::option::Option::None,
2545            unit_packaging: ::std::option::Option::None,
2546            haptic_feedback: ::std::option::Option::None,
2547            recovery_type: ::std::option::Option::None,
2548            optiga_sec: ::std::option::Option::None,
2549            special_fields: ::protobuf::SpecialFields::new(),
2550        };
2551        &instance
2552    }
2553}
2554
2555impl ::protobuf::MessageFull for Features {
2556    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2557        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2558        descriptor.get(|| file_descriptor().message_by_package_relative_name("Features").unwrap()).clone()
2559    }
2560}
2561
2562impl ::std::fmt::Display for Features {
2563    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2564        ::protobuf::text_format::fmt(self, f)
2565    }
2566}
2567
2568impl ::protobuf::reflect::ProtobufValue for Features {
2569    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2570}
2571
2572/// Nested message and enums of message `Features`
2573pub mod features {
2574    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
2575    // @@protoc_insertion_point(enum:hw.trezor.messages.management.Features.BackupAvailability)
2576    pub enum BackupAvailability {
2577        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.BackupAvailability.NotAvailable)
2578        NotAvailable = 0,
2579        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.BackupAvailability.Required)
2580        Required = 1,
2581        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.BackupAvailability.Available)
2582        Available = 2,
2583    }
2584
2585    impl ::protobuf::Enum for BackupAvailability {
2586        const NAME: &'static str = "BackupAvailability";
2587
2588        fn value(&self) -> i32 {
2589            *self as i32
2590        }
2591
2592        fn from_i32(value: i32) -> ::std::option::Option<BackupAvailability> {
2593            match value {
2594                0 => ::std::option::Option::Some(BackupAvailability::NotAvailable),
2595                1 => ::std::option::Option::Some(BackupAvailability::Required),
2596                2 => ::std::option::Option::Some(BackupAvailability::Available),
2597                _ => ::std::option::Option::None
2598            }
2599        }
2600
2601        fn from_str(str: &str) -> ::std::option::Option<BackupAvailability> {
2602            match str {
2603                "NotAvailable" => ::std::option::Option::Some(BackupAvailability::NotAvailable),
2604                "Required" => ::std::option::Option::Some(BackupAvailability::Required),
2605                "Available" => ::std::option::Option::Some(BackupAvailability::Available),
2606                _ => ::std::option::Option::None
2607            }
2608        }
2609
2610        const VALUES: &'static [BackupAvailability] = &[
2611            BackupAvailability::NotAvailable,
2612            BackupAvailability::Required,
2613            BackupAvailability::Available,
2614        ];
2615    }
2616
2617    impl ::protobuf::EnumFull for BackupAvailability {
2618        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
2619            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
2620            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("Features.BackupAvailability").unwrap()).clone()
2621        }
2622
2623        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
2624            let index = *self as usize;
2625            Self::enum_descriptor().value_by_index(index)
2626        }
2627    }
2628
2629    impl ::std::default::Default for BackupAvailability {
2630        fn default() -> Self {
2631            BackupAvailability::NotAvailable
2632        }
2633    }
2634
2635    impl BackupAvailability {
2636        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
2637            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<BackupAvailability>("Features.BackupAvailability")
2638        }
2639    }
2640
2641    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
2642    // @@protoc_insertion_point(enum:hw.trezor.messages.management.Features.RecoveryStatus)
2643    pub enum RecoveryStatus {
2644        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.RecoveryStatus.Nothing)
2645        Nothing = 0,
2646        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.RecoveryStatus.Recovery)
2647        Recovery = 1,
2648        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.RecoveryStatus.Backup)
2649        Backup = 2,
2650    }
2651
2652    impl ::protobuf::Enum for RecoveryStatus {
2653        const NAME: &'static str = "RecoveryStatus";
2654
2655        fn value(&self) -> i32 {
2656            *self as i32
2657        }
2658
2659        fn from_i32(value: i32) -> ::std::option::Option<RecoveryStatus> {
2660            match value {
2661                0 => ::std::option::Option::Some(RecoveryStatus::Nothing),
2662                1 => ::std::option::Option::Some(RecoveryStatus::Recovery),
2663                2 => ::std::option::Option::Some(RecoveryStatus::Backup),
2664                _ => ::std::option::Option::None
2665            }
2666        }
2667
2668        fn from_str(str: &str) -> ::std::option::Option<RecoveryStatus> {
2669            match str {
2670                "Nothing" => ::std::option::Option::Some(RecoveryStatus::Nothing),
2671                "Recovery" => ::std::option::Option::Some(RecoveryStatus::Recovery),
2672                "Backup" => ::std::option::Option::Some(RecoveryStatus::Backup),
2673                _ => ::std::option::Option::None
2674            }
2675        }
2676
2677        const VALUES: &'static [RecoveryStatus] = &[
2678            RecoveryStatus::Nothing,
2679            RecoveryStatus::Recovery,
2680            RecoveryStatus::Backup,
2681        ];
2682    }
2683
2684    impl ::protobuf::EnumFull for RecoveryStatus {
2685        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
2686            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
2687            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("Features.RecoveryStatus").unwrap()).clone()
2688        }
2689
2690        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
2691            let index = *self as usize;
2692            Self::enum_descriptor().value_by_index(index)
2693        }
2694    }
2695
2696    impl ::std::default::Default for RecoveryStatus {
2697        fn default() -> Self {
2698            RecoveryStatus::Nothing
2699        }
2700    }
2701
2702    impl RecoveryStatus {
2703        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
2704            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<RecoveryStatus>("Features.RecoveryStatus")
2705        }
2706    }
2707
2708    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
2709    // @@protoc_insertion_point(enum:hw.trezor.messages.management.Features.Capability)
2710    pub enum Capability {
2711        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Bitcoin)
2712        Capability_Bitcoin = 1,
2713        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Bitcoin_like)
2714        Capability_Bitcoin_like = 2,
2715        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Binance)
2716        Capability_Binance = 3,
2717        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Cardano)
2718        Capability_Cardano = 4,
2719        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Crypto)
2720        Capability_Crypto = 5,
2721        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_EOS)
2722        Capability_EOS = 6,
2723        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Ethereum)
2724        Capability_Ethereum = 7,
2725        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Lisk)
2726        Capability_Lisk = 8,
2727        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Monero)
2728        Capability_Monero = 9,
2729        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_NEM)
2730        Capability_NEM = 10,
2731        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Ripple)
2732        Capability_Ripple = 11,
2733        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Stellar)
2734        Capability_Stellar = 12,
2735        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Tezos)
2736        Capability_Tezos = 13,
2737        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_U2F)
2738        Capability_U2F = 14,
2739        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Shamir)
2740        Capability_Shamir = 15,
2741        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_ShamirGroups)
2742        Capability_ShamirGroups = 16,
2743        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_PassphraseEntry)
2744        Capability_PassphraseEntry = 17,
2745        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Solana)
2746        Capability_Solana = 18,
2747        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Translations)
2748        Capability_Translations = 19,
2749        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Brightness)
2750        Capability_Brightness = 20,
2751        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.Features.Capability.Capability_Haptic)
2752        Capability_Haptic = 21,
2753    }
2754
2755    impl ::protobuf::Enum for Capability {
2756        const NAME: &'static str = "Capability";
2757
2758        fn value(&self) -> i32 {
2759            *self as i32
2760        }
2761
2762        fn from_i32(value: i32) -> ::std::option::Option<Capability> {
2763            match value {
2764                1 => ::std::option::Option::Some(Capability::Capability_Bitcoin),
2765                2 => ::std::option::Option::Some(Capability::Capability_Bitcoin_like),
2766                3 => ::std::option::Option::Some(Capability::Capability_Binance),
2767                4 => ::std::option::Option::Some(Capability::Capability_Cardano),
2768                5 => ::std::option::Option::Some(Capability::Capability_Crypto),
2769                6 => ::std::option::Option::Some(Capability::Capability_EOS),
2770                7 => ::std::option::Option::Some(Capability::Capability_Ethereum),
2771                8 => ::std::option::Option::Some(Capability::Capability_Lisk),
2772                9 => ::std::option::Option::Some(Capability::Capability_Monero),
2773                10 => ::std::option::Option::Some(Capability::Capability_NEM),
2774                11 => ::std::option::Option::Some(Capability::Capability_Ripple),
2775                12 => ::std::option::Option::Some(Capability::Capability_Stellar),
2776                13 => ::std::option::Option::Some(Capability::Capability_Tezos),
2777                14 => ::std::option::Option::Some(Capability::Capability_U2F),
2778                15 => ::std::option::Option::Some(Capability::Capability_Shamir),
2779                16 => ::std::option::Option::Some(Capability::Capability_ShamirGroups),
2780                17 => ::std::option::Option::Some(Capability::Capability_PassphraseEntry),
2781                18 => ::std::option::Option::Some(Capability::Capability_Solana),
2782                19 => ::std::option::Option::Some(Capability::Capability_Translations),
2783                20 => ::std::option::Option::Some(Capability::Capability_Brightness),
2784                21 => ::std::option::Option::Some(Capability::Capability_Haptic),
2785                _ => ::std::option::Option::None
2786            }
2787        }
2788
2789        fn from_str(str: &str) -> ::std::option::Option<Capability> {
2790            match str {
2791                "Capability_Bitcoin" => ::std::option::Option::Some(Capability::Capability_Bitcoin),
2792                "Capability_Bitcoin_like" => ::std::option::Option::Some(Capability::Capability_Bitcoin_like),
2793                "Capability_Binance" => ::std::option::Option::Some(Capability::Capability_Binance),
2794                "Capability_Cardano" => ::std::option::Option::Some(Capability::Capability_Cardano),
2795                "Capability_Crypto" => ::std::option::Option::Some(Capability::Capability_Crypto),
2796                "Capability_EOS" => ::std::option::Option::Some(Capability::Capability_EOS),
2797                "Capability_Ethereum" => ::std::option::Option::Some(Capability::Capability_Ethereum),
2798                "Capability_Lisk" => ::std::option::Option::Some(Capability::Capability_Lisk),
2799                "Capability_Monero" => ::std::option::Option::Some(Capability::Capability_Monero),
2800                "Capability_NEM" => ::std::option::Option::Some(Capability::Capability_NEM),
2801                "Capability_Ripple" => ::std::option::Option::Some(Capability::Capability_Ripple),
2802                "Capability_Stellar" => ::std::option::Option::Some(Capability::Capability_Stellar),
2803                "Capability_Tezos" => ::std::option::Option::Some(Capability::Capability_Tezos),
2804                "Capability_U2F" => ::std::option::Option::Some(Capability::Capability_U2F),
2805                "Capability_Shamir" => ::std::option::Option::Some(Capability::Capability_Shamir),
2806                "Capability_ShamirGroups" => ::std::option::Option::Some(Capability::Capability_ShamirGroups),
2807                "Capability_PassphraseEntry" => ::std::option::Option::Some(Capability::Capability_PassphraseEntry),
2808                "Capability_Solana" => ::std::option::Option::Some(Capability::Capability_Solana),
2809                "Capability_Translations" => ::std::option::Option::Some(Capability::Capability_Translations),
2810                "Capability_Brightness" => ::std::option::Option::Some(Capability::Capability_Brightness),
2811                "Capability_Haptic" => ::std::option::Option::Some(Capability::Capability_Haptic),
2812                _ => ::std::option::Option::None
2813            }
2814        }
2815
2816        const VALUES: &'static [Capability] = &[
2817            Capability::Capability_Bitcoin,
2818            Capability::Capability_Bitcoin_like,
2819            Capability::Capability_Binance,
2820            Capability::Capability_Cardano,
2821            Capability::Capability_Crypto,
2822            Capability::Capability_EOS,
2823            Capability::Capability_Ethereum,
2824            Capability::Capability_Lisk,
2825            Capability::Capability_Monero,
2826            Capability::Capability_NEM,
2827            Capability::Capability_Ripple,
2828            Capability::Capability_Stellar,
2829            Capability::Capability_Tezos,
2830            Capability::Capability_U2F,
2831            Capability::Capability_Shamir,
2832            Capability::Capability_ShamirGroups,
2833            Capability::Capability_PassphraseEntry,
2834            Capability::Capability_Solana,
2835            Capability::Capability_Translations,
2836            Capability::Capability_Brightness,
2837            Capability::Capability_Haptic,
2838        ];
2839    }
2840
2841    impl ::protobuf::EnumFull for Capability {
2842        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
2843            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
2844            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("Features.Capability").unwrap()).clone()
2845        }
2846
2847        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
2848            let index = match self {
2849                Capability::Capability_Bitcoin => 0,
2850                Capability::Capability_Bitcoin_like => 1,
2851                Capability::Capability_Binance => 2,
2852                Capability::Capability_Cardano => 3,
2853                Capability::Capability_Crypto => 4,
2854                Capability::Capability_EOS => 5,
2855                Capability::Capability_Ethereum => 6,
2856                Capability::Capability_Lisk => 7,
2857                Capability::Capability_Monero => 8,
2858                Capability::Capability_NEM => 9,
2859                Capability::Capability_Ripple => 10,
2860                Capability::Capability_Stellar => 11,
2861                Capability::Capability_Tezos => 12,
2862                Capability::Capability_U2F => 13,
2863                Capability::Capability_Shamir => 14,
2864                Capability::Capability_ShamirGroups => 15,
2865                Capability::Capability_PassphraseEntry => 16,
2866                Capability::Capability_Solana => 17,
2867                Capability::Capability_Translations => 18,
2868                Capability::Capability_Brightness => 19,
2869                Capability::Capability_Haptic => 20,
2870            };
2871            Self::enum_descriptor().value_by_index(index)
2872        }
2873    }
2874
2875    // Note, `Default` is implemented although default value is not 0
2876    impl ::std::default::Default for Capability {
2877        fn default() -> Self {
2878            Capability::Capability_Bitcoin
2879        }
2880    }
2881
2882    impl Capability {
2883        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
2884            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<Capability>("Features.Capability")
2885        }
2886    }
2887}
2888
2889// @@protoc_insertion_point(message:hw.trezor.messages.management.LockDevice)
2890#[derive(PartialEq,Clone,Default,Debug)]
2891pub struct LockDevice {
2892    // special fields
2893    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.LockDevice.special_fields)
2894    pub special_fields: ::protobuf::SpecialFields,
2895}
2896
2897impl<'a> ::std::default::Default for &'a LockDevice {
2898    fn default() -> &'a LockDevice {
2899        <LockDevice as ::protobuf::Message>::default_instance()
2900    }
2901}
2902
2903impl LockDevice {
2904    pub fn new() -> LockDevice {
2905        ::std::default::Default::default()
2906    }
2907
2908    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2909        let mut fields = ::std::vec::Vec::with_capacity(0);
2910        let mut oneofs = ::std::vec::Vec::with_capacity(0);
2911        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LockDevice>(
2912            "LockDevice",
2913            fields,
2914            oneofs,
2915        )
2916    }
2917}
2918
2919impl ::protobuf::Message for LockDevice {
2920    const NAME: &'static str = "LockDevice";
2921
2922    fn is_initialized(&self) -> bool {
2923        true
2924    }
2925
2926    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2927        while let Some(tag) = is.read_raw_tag_or_eof()? {
2928            match tag {
2929                tag => {
2930                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2931                },
2932            };
2933        }
2934        ::std::result::Result::Ok(())
2935    }
2936
2937    // Compute sizes of nested messages
2938    #[allow(unused_variables)]
2939    fn compute_size(&self) -> u64 {
2940        let mut my_size = 0;
2941        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2942        self.special_fields.cached_size().set(my_size as u32);
2943        my_size
2944    }
2945
2946    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2947        os.write_unknown_fields(self.special_fields.unknown_fields())?;
2948        ::std::result::Result::Ok(())
2949    }
2950
2951    fn special_fields(&self) -> &::protobuf::SpecialFields {
2952        &self.special_fields
2953    }
2954
2955    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2956        &mut self.special_fields
2957    }
2958
2959    fn new() -> LockDevice {
2960        LockDevice::new()
2961    }
2962
2963    fn clear(&mut self) {
2964        self.special_fields.clear();
2965    }
2966
2967    fn default_instance() -> &'static LockDevice {
2968        static instance: LockDevice = LockDevice {
2969            special_fields: ::protobuf::SpecialFields::new(),
2970        };
2971        &instance
2972    }
2973}
2974
2975impl ::protobuf::MessageFull for LockDevice {
2976    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2977        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2978        descriptor.get(|| file_descriptor().message_by_package_relative_name("LockDevice").unwrap()).clone()
2979    }
2980}
2981
2982impl ::std::fmt::Display for LockDevice {
2983    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2984        ::protobuf::text_format::fmt(self, f)
2985    }
2986}
2987
2988impl ::protobuf::reflect::ProtobufValue for LockDevice {
2989    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2990}
2991
2992// @@protoc_insertion_point(message:hw.trezor.messages.management.SetBusy)
2993#[derive(PartialEq,Clone,Default,Debug)]
2994pub struct SetBusy {
2995    // message fields
2996    // @@protoc_insertion_point(field:hw.trezor.messages.management.SetBusy.expiry_ms)
2997    pub expiry_ms: ::std::option::Option<u32>,
2998    // special fields
2999    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.SetBusy.special_fields)
3000    pub special_fields: ::protobuf::SpecialFields,
3001}
3002
3003impl<'a> ::std::default::Default for &'a SetBusy {
3004    fn default() -> &'a SetBusy {
3005        <SetBusy as ::protobuf::Message>::default_instance()
3006    }
3007}
3008
3009impl SetBusy {
3010    pub fn new() -> SetBusy {
3011        ::std::default::Default::default()
3012    }
3013
3014    // optional uint32 expiry_ms = 1;
3015
3016    pub fn expiry_ms(&self) -> u32 {
3017        self.expiry_ms.unwrap_or(0)
3018    }
3019
3020    pub fn clear_expiry_ms(&mut self) {
3021        self.expiry_ms = ::std::option::Option::None;
3022    }
3023
3024    pub fn has_expiry_ms(&self) -> bool {
3025        self.expiry_ms.is_some()
3026    }
3027
3028    // Param is passed by value, moved
3029    pub fn set_expiry_ms(&mut self, v: u32) {
3030        self.expiry_ms = ::std::option::Option::Some(v);
3031    }
3032
3033    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3034        let mut fields = ::std::vec::Vec::with_capacity(1);
3035        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3036        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3037            "expiry_ms",
3038            |m: &SetBusy| { &m.expiry_ms },
3039            |m: &mut SetBusy| { &mut m.expiry_ms },
3040        ));
3041        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetBusy>(
3042            "SetBusy",
3043            fields,
3044            oneofs,
3045        )
3046    }
3047}
3048
3049impl ::protobuf::Message for SetBusy {
3050    const NAME: &'static str = "SetBusy";
3051
3052    fn is_initialized(&self) -> bool {
3053        true
3054    }
3055
3056    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3057        while let Some(tag) = is.read_raw_tag_or_eof()? {
3058            match tag {
3059                8 => {
3060                    self.expiry_ms = ::std::option::Option::Some(is.read_uint32()?);
3061                },
3062                tag => {
3063                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3064                },
3065            };
3066        }
3067        ::std::result::Result::Ok(())
3068    }
3069
3070    // Compute sizes of nested messages
3071    #[allow(unused_variables)]
3072    fn compute_size(&self) -> u64 {
3073        let mut my_size = 0;
3074        if let Some(v) = self.expiry_ms {
3075            my_size += ::protobuf::rt::uint32_size(1, v);
3076        }
3077        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3078        self.special_fields.cached_size().set(my_size as u32);
3079        my_size
3080    }
3081
3082    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3083        if let Some(v) = self.expiry_ms {
3084            os.write_uint32(1, v)?;
3085        }
3086        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3087        ::std::result::Result::Ok(())
3088    }
3089
3090    fn special_fields(&self) -> &::protobuf::SpecialFields {
3091        &self.special_fields
3092    }
3093
3094    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3095        &mut self.special_fields
3096    }
3097
3098    fn new() -> SetBusy {
3099        SetBusy::new()
3100    }
3101
3102    fn clear(&mut self) {
3103        self.expiry_ms = ::std::option::Option::None;
3104        self.special_fields.clear();
3105    }
3106
3107    fn default_instance() -> &'static SetBusy {
3108        static instance: SetBusy = SetBusy {
3109            expiry_ms: ::std::option::Option::None,
3110            special_fields: ::protobuf::SpecialFields::new(),
3111        };
3112        &instance
3113    }
3114}
3115
3116impl ::protobuf::MessageFull for SetBusy {
3117    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3118        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3119        descriptor.get(|| file_descriptor().message_by_package_relative_name("SetBusy").unwrap()).clone()
3120    }
3121}
3122
3123impl ::std::fmt::Display for SetBusy {
3124    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3125        ::protobuf::text_format::fmt(self, f)
3126    }
3127}
3128
3129impl ::protobuf::reflect::ProtobufValue for SetBusy {
3130    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3131}
3132
3133// @@protoc_insertion_point(message:hw.trezor.messages.management.EndSession)
3134#[derive(PartialEq,Clone,Default,Debug)]
3135pub struct EndSession {
3136    // special fields
3137    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EndSession.special_fields)
3138    pub special_fields: ::protobuf::SpecialFields,
3139}
3140
3141impl<'a> ::std::default::Default for &'a EndSession {
3142    fn default() -> &'a EndSession {
3143        <EndSession as ::protobuf::Message>::default_instance()
3144    }
3145}
3146
3147impl EndSession {
3148    pub fn new() -> EndSession {
3149        ::std::default::Default::default()
3150    }
3151
3152    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3153        let mut fields = ::std::vec::Vec::with_capacity(0);
3154        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3155        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EndSession>(
3156            "EndSession",
3157            fields,
3158            oneofs,
3159        )
3160    }
3161}
3162
3163impl ::protobuf::Message for EndSession {
3164    const NAME: &'static str = "EndSession";
3165
3166    fn is_initialized(&self) -> bool {
3167        true
3168    }
3169
3170    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3171        while let Some(tag) = is.read_raw_tag_or_eof()? {
3172            match tag {
3173                tag => {
3174                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3175                },
3176            };
3177        }
3178        ::std::result::Result::Ok(())
3179    }
3180
3181    // Compute sizes of nested messages
3182    #[allow(unused_variables)]
3183    fn compute_size(&self) -> u64 {
3184        let mut my_size = 0;
3185        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3186        self.special_fields.cached_size().set(my_size as u32);
3187        my_size
3188    }
3189
3190    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3191        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3192        ::std::result::Result::Ok(())
3193    }
3194
3195    fn special_fields(&self) -> &::protobuf::SpecialFields {
3196        &self.special_fields
3197    }
3198
3199    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3200        &mut self.special_fields
3201    }
3202
3203    fn new() -> EndSession {
3204        EndSession::new()
3205    }
3206
3207    fn clear(&mut self) {
3208        self.special_fields.clear();
3209    }
3210
3211    fn default_instance() -> &'static EndSession {
3212        static instance: EndSession = EndSession {
3213            special_fields: ::protobuf::SpecialFields::new(),
3214        };
3215        &instance
3216    }
3217}
3218
3219impl ::protobuf::MessageFull for EndSession {
3220    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3221        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3222        descriptor.get(|| file_descriptor().message_by_package_relative_name("EndSession").unwrap()).clone()
3223    }
3224}
3225
3226impl ::std::fmt::Display for EndSession {
3227    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3228        ::protobuf::text_format::fmt(self, f)
3229    }
3230}
3231
3232impl ::protobuf::reflect::ProtobufValue for EndSession {
3233    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3234}
3235
3236// @@protoc_insertion_point(message:hw.trezor.messages.management.ApplySettings)
3237#[derive(PartialEq,Clone,Default,Debug)]
3238pub struct ApplySettings {
3239    // message fields
3240    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.language)
3241    pub language: ::std::option::Option<::std::string::String>,
3242    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.label)
3243    pub label: ::std::option::Option<::std::string::String>,
3244    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.use_passphrase)
3245    pub use_passphrase: ::std::option::Option<bool>,
3246    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.homescreen)
3247    pub homescreen: ::std::option::Option<::std::vec::Vec<u8>>,
3248    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings._passphrase_source)
3249    pub _passphrase_source: ::std::option::Option<u32>,
3250    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.auto_lock_delay_ms)
3251    pub auto_lock_delay_ms: ::std::option::Option<u32>,
3252    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.display_rotation)
3253    pub display_rotation: ::std::option::Option<u32>,
3254    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.passphrase_always_on_device)
3255    pub passphrase_always_on_device: ::std::option::Option<bool>,
3256    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.safety_checks)
3257    pub safety_checks: ::std::option::Option<::protobuf::EnumOrUnknown<SafetyCheckLevel>>,
3258    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.experimental_features)
3259    pub experimental_features: ::std::option::Option<bool>,
3260    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.hide_passphrase_from_host)
3261    pub hide_passphrase_from_host: ::std::option::Option<bool>,
3262    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplySettings.haptic_feedback)
3263    pub haptic_feedback: ::std::option::Option<bool>,
3264    // special fields
3265    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ApplySettings.special_fields)
3266    pub special_fields: ::protobuf::SpecialFields,
3267}
3268
3269impl<'a> ::std::default::Default for &'a ApplySettings {
3270    fn default() -> &'a ApplySettings {
3271        <ApplySettings as ::protobuf::Message>::default_instance()
3272    }
3273}
3274
3275impl ApplySettings {
3276    pub fn new() -> ApplySettings {
3277        ::std::default::Default::default()
3278    }
3279
3280    // optional string language = 1;
3281
3282    pub fn language(&self) -> &str {
3283        match self.language.as_ref() {
3284            Some(v) => v,
3285            None => "",
3286        }
3287    }
3288
3289    pub fn clear_language(&mut self) {
3290        self.language = ::std::option::Option::None;
3291    }
3292
3293    pub fn has_language(&self) -> bool {
3294        self.language.is_some()
3295    }
3296
3297    // Param is passed by value, moved
3298    pub fn set_language(&mut self, v: ::std::string::String) {
3299        self.language = ::std::option::Option::Some(v);
3300    }
3301
3302    // Mutable pointer to the field.
3303    // If field is not initialized, it is initialized with default value first.
3304    pub fn mut_language(&mut self) -> &mut ::std::string::String {
3305        if self.language.is_none() {
3306            self.language = ::std::option::Option::Some(::std::string::String::new());
3307        }
3308        self.language.as_mut().unwrap()
3309    }
3310
3311    // Take field
3312    pub fn take_language(&mut self) -> ::std::string::String {
3313        self.language.take().unwrap_or_else(|| ::std::string::String::new())
3314    }
3315
3316    // optional string label = 2;
3317
3318    pub fn label(&self) -> &str {
3319        match self.label.as_ref() {
3320            Some(v) => v,
3321            None => "",
3322        }
3323    }
3324
3325    pub fn clear_label(&mut self) {
3326        self.label = ::std::option::Option::None;
3327    }
3328
3329    pub fn has_label(&self) -> bool {
3330        self.label.is_some()
3331    }
3332
3333    // Param is passed by value, moved
3334    pub fn set_label(&mut self, v: ::std::string::String) {
3335        self.label = ::std::option::Option::Some(v);
3336    }
3337
3338    // Mutable pointer to the field.
3339    // If field is not initialized, it is initialized with default value first.
3340    pub fn mut_label(&mut self) -> &mut ::std::string::String {
3341        if self.label.is_none() {
3342            self.label = ::std::option::Option::Some(::std::string::String::new());
3343        }
3344        self.label.as_mut().unwrap()
3345    }
3346
3347    // Take field
3348    pub fn take_label(&mut self) -> ::std::string::String {
3349        self.label.take().unwrap_or_else(|| ::std::string::String::new())
3350    }
3351
3352    // optional bool use_passphrase = 3;
3353
3354    pub fn use_passphrase(&self) -> bool {
3355        self.use_passphrase.unwrap_or(false)
3356    }
3357
3358    pub fn clear_use_passphrase(&mut self) {
3359        self.use_passphrase = ::std::option::Option::None;
3360    }
3361
3362    pub fn has_use_passphrase(&self) -> bool {
3363        self.use_passphrase.is_some()
3364    }
3365
3366    // Param is passed by value, moved
3367    pub fn set_use_passphrase(&mut self, v: bool) {
3368        self.use_passphrase = ::std::option::Option::Some(v);
3369    }
3370
3371    // optional bytes homescreen = 4;
3372
3373    pub fn homescreen(&self) -> &[u8] {
3374        match self.homescreen.as_ref() {
3375            Some(v) => v,
3376            None => &[],
3377        }
3378    }
3379
3380    pub fn clear_homescreen(&mut self) {
3381        self.homescreen = ::std::option::Option::None;
3382    }
3383
3384    pub fn has_homescreen(&self) -> bool {
3385        self.homescreen.is_some()
3386    }
3387
3388    // Param is passed by value, moved
3389    pub fn set_homescreen(&mut self, v: ::std::vec::Vec<u8>) {
3390        self.homescreen = ::std::option::Option::Some(v);
3391    }
3392
3393    // Mutable pointer to the field.
3394    // If field is not initialized, it is initialized with default value first.
3395    pub fn mut_homescreen(&mut self) -> &mut ::std::vec::Vec<u8> {
3396        if self.homescreen.is_none() {
3397            self.homescreen = ::std::option::Option::Some(::std::vec::Vec::new());
3398        }
3399        self.homescreen.as_mut().unwrap()
3400    }
3401
3402    // Take field
3403    pub fn take_homescreen(&mut self) -> ::std::vec::Vec<u8> {
3404        self.homescreen.take().unwrap_or_else(|| ::std::vec::Vec::new())
3405    }
3406
3407    // optional uint32 _passphrase_source = 5;
3408
3409    pub fn _passphrase_source(&self) -> u32 {
3410        self._passphrase_source.unwrap_or(0)
3411    }
3412
3413    pub fn clear__passphrase_source(&mut self) {
3414        self._passphrase_source = ::std::option::Option::None;
3415    }
3416
3417    pub fn has__passphrase_source(&self) -> bool {
3418        self._passphrase_source.is_some()
3419    }
3420
3421    // Param is passed by value, moved
3422    pub fn set__passphrase_source(&mut self, v: u32) {
3423        self._passphrase_source = ::std::option::Option::Some(v);
3424    }
3425
3426    // optional uint32 auto_lock_delay_ms = 6;
3427
3428    pub fn auto_lock_delay_ms(&self) -> u32 {
3429        self.auto_lock_delay_ms.unwrap_or(0)
3430    }
3431
3432    pub fn clear_auto_lock_delay_ms(&mut self) {
3433        self.auto_lock_delay_ms = ::std::option::Option::None;
3434    }
3435
3436    pub fn has_auto_lock_delay_ms(&self) -> bool {
3437        self.auto_lock_delay_ms.is_some()
3438    }
3439
3440    // Param is passed by value, moved
3441    pub fn set_auto_lock_delay_ms(&mut self, v: u32) {
3442        self.auto_lock_delay_ms = ::std::option::Option::Some(v);
3443    }
3444
3445    // optional uint32 display_rotation = 7;
3446
3447    pub fn display_rotation(&self) -> u32 {
3448        self.display_rotation.unwrap_or(0)
3449    }
3450
3451    pub fn clear_display_rotation(&mut self) {
3452        self.display_rotation = ::std::option::Option::None;
3453    }
3454
3455    pub fn has_display_rotation(&self) -> bool {
3456        self.display_rotation.is_some()
3457    }
3458
3459    // Param is passed by value, moved
3460    pub fn set_display_rotation(&mut self, v: u32) {
3461        self.display_rotation = ::std::option::Option::Some(v);
3462    }
3463
3464    // optional bool passphrase_always_on_device = 8;
3465
3466    pub fn passphrase_always_on_device(&self) -> bool {
3467        self.passphrase_always_on_device.unwrap_or(false)
3468    }
3469
3470    pub fn clear_passphrase_always_on_device(&mut self) {
3471        self.passphrase_always_on_device = ::std::option::Option::None;
3472    }
3473
3474    pub fn has_passphrase_always_on_device(&self) -> bool {
3475        self.passphrase_always_on_device.is_some()
3476    }
3477
3478    // Param is passed by value, moved
3479    pub fn set_passphrase_always_on_device(&mut self, v: bool) {
3480        self.passphrase_always_on_device = ::std::option::Option::Some(v);
3481    }
3482
3483    // optional .hw.trezor.messages.management.SafetyCheckLevel safety_checks = 9;
3484
3485    pub fn safety_checks(&self) -> SafetyCheckLevel {
3486        match self.safety_checks {
3487            Some(e) => e.enum_value_or(SafetyCheckLevel::Strict),
3488            None => SafetyCheckLevel::Strict,
3489        }
3490    }
3491
3492    pub fn clear_safety_checks(&mut self) {
3493        self.safety_checks = ::std::option::Option::None;
3494    }
3495
3496    pub fn has_safety_checks(&self) -> bool {
3497        self.safety_checks.is_some()
3498    }
3499
3500    // Param is passed by value, moved
3501    pub fn set_safety_checks(&mut self, v: SafetyCheckLevel) {
3502        self.safety_checks = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
3503    }
3504
3505    // optional bool experimental_features = 10;
3506
3507    pub fn experimental_features(&self) -> bool {
3508        self.experimental_features.unwrap_or(false)
3509    }
3510
3511    pub fn clear_experimental_features(&mut self) {
3512        self.experimental_features = ::std::option::Option::None;
3513    }
3514
3515    pub fn has_experimental_features(&self) -> bool {
3516        self.experimental_features.is_some()
3517    }
3518
3519    // Param is passed by value, moved
3520    pub fn set_experimental_features(&mut self, v: bool) {
3521        self.experimental_features = ::std::option::Option::Some(v);
3522    }
3523
3524    // optional bool hide_passphrase_from_host = 11;
3525
3526    pub fn hide_passphrase_from_host(&self) -> bool {
3527        self.hide_passphrase_from_host.unwrap_or(false)
3528    }
3529
3530    pub fn clear_hide_passphrase_from_host(&mut self) {
3531        self.hide_passphrase_from_host = ::std::option::Option::None;
3532    }
3533
3534    pub fn has_hide_passphrase_from_host(&self) -> bool {
3535        self.hide_passphrase_from_host.is_some()
3536    }
3537
3538    // Param is passed by value, moved
3539    pub fn set_hide_passphrase_from_host(&mut self, v: bool) {
3540        self.hide_passphrase_from_host = ::std::option::Option::Some(v);
3541    }
3542
3543    // optional bool haptic_feedback = 13;
3544
3545    pub fn haptic_feedback(&self) -> bool {
3546        self.haptic_feedback.unwrap_or(false)
3547    }
3548
3549    pub fn clear_haptic_feedback(&mut self) {
3550        self.haptic_feedback = ::std::option::Option::None;
3551    }
3552
3553    pub fn has_haptic_feedback(&self) -> bool {
3554        self.haptic_feedback.is_some()
3555    }
3556
3557    // Param is passed by value, moved
3558    pub fn set_haptic_feedback(&mut self, v: bool) {
3559        self.haptic_feedback = ::std::option::Option::Some(v);
3560    }
3561
3562    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3563        let mut fields = ::std::vec::Vec::with_capacity(12);
3564        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3565        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3566            "language",
3567            |m: &ApplySettings| { &m.language },
3568            |m: &mut ApplySettings| { &mut m.language },
3569        ));
3570        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3571            "label",
3572            |m: &ApplySettings| { &m.label },
3573            |m: &mut ApplySettings| { &mut m.label },
3574        ));
3575        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3576            "use_passphrase",
3577            |m: &ApplySettings| { &m.use_passphrase },
3578            |m: &mut ApplySettings| { &mut m.use_passphrase },
3579        ));
3580        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3581            "homescreen",
3582            |m: &ApplySettings| { &m.homescreen },
3583            |m: &mut ApplySettings| { &mut m.homescreen },
3584        ));
3585        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3586            "_passphrase_source",
3587            |m: &ApplySettings| { &m._passphrase_source },
3588            |m: &mut ApplySettings| { &mut m._passphrase_source },
3589        ));
3590        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3591            "auto_lock_delay_ms",
3592            |m: &ApplySettings| { &m.auto_lock_delay_ms },
3593            |m: &mut ApplySettings| { &mut m.auto_lock_delay_ms },
3594        ));
3595        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3596            "display_rotation",
3597            |m: &ApplySettings| { &m.display_rotation },
3598            |m: &mut ApplySettings| { &mut m.display_rotation },
3599        ));
3600        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3601            "passphrase_always_on_device",
3602            |m: &ApplySettings| { &m.passphrase_always_on_device },
3603            |m: &mut ApplySettings| { &mut m.passphrase_always_on_device },
3604        ));
3605        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3606            "safety_checks",
3607            |m: &ApplySettings| { &m.safety_checks },
3608            |m: &mut ApplySettings| { &mut m.safety_checks },
3609        ));
3610        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3611            "experimental_features",
3612            |m: &ApplySettings| { &m.experimental_features },
3613            |m: &mut ApplySettings| { &mut m.experimental_features },
3614        ));
3615        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3616            "hide_passphrase_from_host",
3617            |m: &ApplySettings| { &m.hide_passphrase_from_host },
3618            |m: &mut ApplySettings| { &mut m.hide_passphrase_from_host },
3619        ));
3620        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3621            "haptic_feedback",
3622            |m: &ApplySettings| { &m.haptic_feedback },
3623            |m: &mut ApplySettings| { &mut m.haptic_feedback },
3624        ));
3625        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ApplySettings>(
3626            "ApplySettings",
3627            fields,
3628            oneofs,
3629        )
3630    }
3631}
3632
3633impl ::protobuf::Message for ApplySettings {
3634    const NAME: &'static str = "ApplySettings";
3635
3636    fn is_initialized(&self) -> bool {
3637        true
3638    }
3639
3640    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3641        while let Some(tag) = is.read_raw_tag_or_eof()? {
3642            match tag {
3643                10 => {
3644                    self.language = ::std::option::Option::Some(is.read_string()?);
3645                },
3646                18 => {
3647                    self.label = ::std::option::Option::Some(is.read_string()?);
3648                },
3649                24 => {
3650                    self.use_passphrase = ::std::option::Option::Some(is.read_bool()?);
3651                },
3652                34 => {
3653                    self.homescreen = ::std::option::Option::Some(is.read_bytes()?);
3654                },
3655                40 => {
3656                    self._passphrase_source = ::std::option::Option::Some(is.read_uint32()?);
3657                },
3658                48 => {
3659                    self.auto_lock_delay_ms = ::std::option::Option::Some(is.read_uint32()?);
3660                },
3661                56 => {
3662                    self.display_rotation = ::std::option::Option::Some(is.read_uint32()?);
3663                },
3664                64 => {
3665                    self.passphrase_always_on_device = ::std::option::Option::Some(is.read_bool()?);
3666                },
3667                72 => {
3668                    self.safety_checks = ::std::option::Option::Some(is.read_enum_or_unknown()?);
3669                },
3670                80 => {
3671                    self.experimental_features = ::std::option::Option::Some(is.read_bool()?);
3672                },
3673                88 => {
3674                    self.hide_passphrase_from_host = ::std::option::Option::Some(is.read_bool()?);
3675                },
3676                104 => {
3677                    self.haptic_feedback = ::std::option::Option::Some(is.read_bool()?);
3678                },
3679                tag => {
3680                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3681                },
3682            };
3683        }
3684        ::std::result::Result::Ok(())
3685    }
3686
3687    // Compute sizes of nested messages
3688    #[allow(unused_variables)]
3689    fn compute_size(&self) -> u64 {
3690        let mut my_size = 0;
3691        if let Some(v) = self.language.as_ref() {
3692            my_size += ::protobuf::rt::string_size(1, &v);
3693        }
3694        if let Some(v) = self.label.as_ref() {
3695            my_size += ::protobuf::rt::string_size(2, &v);
3696        }
3697        if let Some(v) = self.use_passphrase {
3698            my_size += 1 + 1;
3699        }
3700        if let Some(v) = self.homescreen.as_ref() {
3701            my_size += ::protobuf::rt::bytes_size(4, &v);
3702        }
3703        if let Some(v) = self._passphrase_source {
3704            my_size += ::protobuf::rt::uint32_size(5, v);
3705        }
3706        if let Some(v) = self.auto_lock_delay_ms {
3707            my_size += ::protobuf::rt::uint32_size(6, v);
3708        }
3709        if let Some(v) = self.display_rotation {
3710            my_size += ::protobuf::rt::uint32_size(7, v);
3711        }
3712        if let Some(v) = self.passphrase_always_on_device {
3713            my_size += 1 + 1;
3714        }
3715        if let Some(v) = self.safety_checks {
3716            my_size += ::protobuf::rt::int32_size(9, v.value());
3717        }
3718        if let Some(v) = self.experimental_features {
3719            my_size += 1 + 1;
3720        }
3721        if let Some(v) = self.hide_passphrase_from_host {
3722            my_size += 1 + 1;
3723        }
3724        if let Some(v) = self.haptic_feedback {
3725            my_size += 1 + 1;
3726        }
3727        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3728        self.special_fields.cached_size().set(my_size as u32);
3729        my_size
3730    }
3731
3732    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3733        if let Some(v) = self.language.as_ref() {
3734            os.write_string(1, v)?;
3735        }
3736        if let Some(v) = self.label.as_ref() {
3737            os.write_string(2, v)?;
3738        }
3739        if let Some(v) = self.use_passphrase {
3740            os.write_bool(3, v)?;
3741        }
3742        if let Some(v) = self.homescreen.as_ref() {
3743            os.write_bytes(4, v)?;
3744        }
3745        if let Some(v) = self._passphrase_source {
3746            os.write_uint32(5, v)?;
3747        }
3748        if let Some(v) = self.auto_lock_delay_ms {
3749            os.write_uint32(6, v)?;
3750        }
3751        if let Some(v) = self.display_rotation {
3752            os.write_uint32(7, v)?;
3753        }
3754        if let Some(v) = self.passphrase_always_on_device {
3755            os.write_bool(8, v)?;
3756        }
3757        if let Some(v) = self.safety_checks {
3758            os.write_enum(9, ::protobuf::EnumOrUnknown::value(&v))?;
3759        }
3760        if let Some(v) = self.experimental_features {
3761            os.write_bool(10, v)?;
3762        }
3763        if let Some(v) = self.hide_passphrase_from_host {
3764            os.write_bool(11, v)?;
3765        }
3766        if let Some(v) = self.haptic_feedback {
3767            os.write_bool(13, v)?;
3768        }
3769        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3770        ::std::result::Result::Ok(())
3771    }
3772
3773    fn special_fields(&self) -> &::protobuf::SpecialFields {
3774        &self.special_fields
3775    }
3776
3777    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3778        &mut self.special_fields
3779    }
3780
3781    fn new() -> ApplySettings {
3782        ApplySettings::new()
3783    }
3784
3785    fn clear(&mut self) {
3786        self.language = ::std::option::Option::None;
3787        self.label = ::std::option::Option::None;
3788        self.use_passphrase = ::std::option::Option::None;
3789        self.homescreen = ::std::option::Option::None;
3790        self._passphrase_source = ::std::option::Option::None;
3791        self.auto_lock_delay_ms = ::std::option::Option::None;
3792        self.display_rotation = ::std::option::Option::None;
3793        self.passphrase_always_on_device = ::std::option::Option::None;
3794        self.safety_checks = ::std::option::Option::None;
3795        self.experimental_features = ::std::option::Option::None;
3796        self.hide_passphrase_from_host = ::std::option::Option::None;
3797        self.haptic_feedback = ::std::option::Option::None;
3798        self.special_fields.clear();
3799    }
3800
3801    fn default_instance() -> &'static ApplySettings {
3802        static instance: ApplySettings = ApplySettings {
3803            language: ::std::option::Option::None,
3804            label: ::std::option::Option::None,
3805            use_passphrase: ::std::option::Option::None,
3806            homescreen: ::std::option::Option::None,
3807            _passphrase_source: ::std::option::Option::None,
3808            auto_lock_delay_ms: ::std::option::Option::None,
3809            display_rotation: ::std::option::Option::None,
3810            passphrase_always_on_device: ::std::option::Option::None,
3811            safety_checks: ::std::option::Option::None,
3812            experimental_features: ::std::option::Option::None,
3813            hide_passphrase_from_host: ::std::option::Option::None,
3814            haptic_feedback: ::std::option::Option::None,
3815            special_fields: ::protobuf::SpecialFields::new(),
3816        };
3817        &instance
3818    }
3819}
3820
3821impl ::protobuf::MessageFull for ApplySettings {
3822    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
3823        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
3824        descriptor.get(|| file_descriptor().message_by_package_relative_name("ApplySettings").unwrap()).clone()
3825    }
3826}
3827
3828impl ::std::fmt::Display for ApplySettings {
3829    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
3830        ::protobuf::text_format::fmt(self, f)
3831    }
3832}
3833
3834impl ::protobuf::reflect::ProtobufValue for ApplySettings {
3835    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
3836}
3837
3838// @@protoc_insertion_point(message:hw.trezor.messages.management.ChangeLanguage)
3839#[derive(PartialEq,Clone,Default,Debug)]
3840pub struct ChangeLanguage {
3841    // message fields
3842    // @@protoc_insertion_point(field:hw.trezor.messages.management.ChangeLanguage.data_length)
3843    pub data_length: ::std::option::Option<u32>,
3844    // @@protoc_insertion_point(field:hw.trezor.messages.management.ChangeLanguage.show_display)
3845    pub show_display: ::std::option::Option<bool>,
3846    // special fields
3847    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ChangeLanguage.special_fields)
3848    pub special_fields: ::protobuf::SpecialFields,
3849}
3850
3851impl<'a> ::std::default::Default for &'a ChangeLanguage {
3852    fn default() -> &'a ChangeLanguage {
3853        <ChangeLanguage as ::protobuf::Message>::default_instance()
3854    }
3855}
3856
3857impl ChangeLanguage {
3858    pub fn new() -> ChangeLanguage {
3859        ::std::default::Default::default()
3860    }
3861
3862    // required uint32 data_length = 1;
3863
3864    pub fn data_length(&self) -> u32 {
3865        self.data_length.unwrap_or(0)
3866    }
3867
3868    pub fn clear_data_length(&mut self) {
3869        self.data_length = ::std::option::Option::None;
3870    }
3871
3872    pub fn has_data_length(&self) -> bool {
3873        self.data_length.is_some()
3874    }
3875
3876    // Param is passed by value, moved
3877    pub fn set_data_length(&mut self, v: u32) {
3878        self.data_length = ::std::option::Option::Some(v);
3879    }
3880
3881    // optional bool show_display = 2;
3882
3883    pub fn show_display(&self) -> bool {
3884        self.show_display.unwrap_or(false)
3885    }
3886
3887    pub fn clear_show_display(&mut self) {
3888        self.show_display = ::std::option::Option::None;
3889    }
3890
3891    pub fn has_show_display(&self) -> bool {
3892        self.show_display.is_some()
3893    }
3894
3895    // Param is passed by value, moved
3896    pub fn set_show_display(&mut self, v: bool) {
3897        self.show_display = ::std::option::Option::Some(v);
3898    }
3899
3900    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
3901        let mut fields = ::std::vec::Vec::with_capacity(2);
3902        let mut oneofs = ::std::vec::Vec::with_capacity(0);
3903        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3904            "data_length",
3905            |m: &ChangeLanguage| { &m.data_length },
3906            |m: &mut ChangeLanguage| { &mut m.data_length },
3907        ));
3908        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
3909            "show_display",
3910            |m: &ChangeLanguage| { &m.show_display },
3911            |m: &mut ChangeLanguage| { &mut m.show_display },
3912        ));
3913        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ChangeLanguage>(
3914            "ChangeLanguage",
3915            fields,
3916            oneofs,
3917        )
3918    }
3919}
3920
3921impl ::protobuf::Message for ChangeLanguage {
3922    const NAME: &'static str = "ChangeLanguage";
3923
3924    fn is_initialized(&self) -> bool {
3925        if self.data_length.is_none() {
3926            return false;
3927        }
3928        true
3929    }
3930
3931    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
3932        while let Some(tag) = is.read_raw_tag_or_eof()? {
3933            match tag {
3934                8 => {
3935                    self.data_length = ::std::option::Option::Some(is.read_uint32()?);
3936                },
3937                16 => {
3938                    self.show_display = ::std::option::Option::Some(is.read_bool()?);
3939                },
3940                tag => {
3941                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
3942                },
3943            };
3944        }
3945        ::std::result::Result::Ok(())
3946    }
3947
3948    // Compute sizes of nested messages
3949    #[allow(unused_variables)]
3950    fn compute_size(&self) -> u64 {
3951        let mut my_size = 0;
3952        if let Some(v) = self.data_length {
3953            my_size += ::protobuf::rt::uint32_size(1, v);
3954        }
3955        if let Some(v) = self.show_display {
3956            my_size += 1 + 1;
3957        }
3958        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
3959        self.special_fields.cached_size().set(my_size as u32);
3960        my_size
3961    }
3962
3963    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
3964        if let Some(v) = self.data_length {
3965            os.write_uint32(1, v)?;
3966        }
3967        if let Some(v) = self.show_display {
3968            os.write_bool(2, v)?;
3969        }
3970        os.write_unknown_fields(self.special_fields.unknown_fields())?;
3971        ::std::result::Result::Ok(())
3972    }
3973
3974    fn special_fields(&self) -> &::protobuf::SpecialFields {
3975        &self.special_fields
3976    }
3977
3978    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
3979        &mut self.special_fields
3980    }
3981
3982    fn new() -> ChangeLanguage {
3983        ChangeLanguage::new()
3984    }
3985
3986    fn clear(&mut self) {
3987        self.data_length = ::std::option::Option::None;
3988        self.show_display = ::std::option::Option::None;
3989        self.special_fields.clear();
3990    }
3991
3992    fn default_instance() -> &'static ChangeLanguage {
3993        static instance: ChangeLanguage = ChangeLanguage {
3994            data_length: ::std::option::Option::None,
3995            show_display: ::std::option::Option::None,
3996            special_fields: ::protobuf::SpecialFields::new(),
3997        };
3998        &instance
3999    }
4000}
4001
4002impl ::protobuf::MessageFull for ChangeLanguage {
4003    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4004        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4005        descriptor.get(|| file_descriptor().message_by_package_relative_name("ChangeLanguage").unwrap()).clone()
4006    }
4007}
4008
4009impl ::std::fmt::Display for ChangeLanguage {
4010    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4011        ::protobuf::text_format::fmt(self, f)
4012    }
4013}
4014
4015impl ::protobuf::reflect::ProtobufValue for ChangeLanguage {
4016    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4017}
4018
4019// @@protoc_insertion_point(message:hw.trezor.messages.management.TranslationDataRequest)
4020#[derive(PartialEq,Clone,Default,Debug)]
4021pub struct TranslationDataRequest {
4022    // message fields
4023    // @@protoc_insertion_point(field:hw.trezor.messages.management.TranslationDataRequest.data_length)
4024    pub data_length: ::std::option::Option<u32>,
4025    // @@protoc_insertion_point(field:hw.trezor.messages.management.TranslationDataRequest.data_offset)
4026    pub data_offset: ::std::option::Option<u32>,
4027    // special fields
4028    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.TranslationDataRequest.special_fields)
4029    pub special_fields: ::protobuf::SpecialFields,
4030}
4031
4032impl<'a> ::std::default::Default for &'a TranslationDataRequest {
4033    fn default() -> &'a TranslationDataRequest {
4034        <TranslationDataRequest as ::protobuf::Message>::default_instance()
4035    }
4036}
4037
4038impl TranslationDataRequest {
4039    pub fn new() -> TranslationDataRequest {
4040        ::std::default::Default::default()
4041    }
4042
4043    // required uint32 data_length = 1;
4044
4045    pub fn data_length(&self) -> u32 {
4046        self.data_length.unwrap_or(0)
4047    }
4048
4049    pub fn clear_data_length(&mut self) {
4050        self.data_length = ::std::option::Option::None;
4051    }
4052
4053    pub fn has_data_length(&self) -> bool {
4054        self.data_length.is_some()
4055    }
4056
4057    // Param is passed by value, moved
4058    pub fn set_data_length(&mut self, v: u32) {
4059        self.data_length = ::std::option::Option::Some(v);
4060    }
4061
4062    // required uint32 data_offset = 2;
4063
4064    pub fn data_offset(&self) -> u32 {
4065        self.data_offset.unwrap_or(0)
4066    }
4067
4068    pub fn clear_data_offset(&mut self) {
4069        self.data_offset = ::std::option::Option::None;
4070    }
4071
4072    pub fn has_data_offset(&self) -> bool {
4073        self.data_offset.is_some()
4074    }
4075
4076    // Param is passed by value, moved
4077    pub fn set_data_offset(&mut self, v: u32) {
4078        self.data_offset = ::std::option::Option::Some(v);
4079    }
4080
4081    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4082        let mut fields = ::std::vec::Vec::with_capacity(2);
4083        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4084        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4085            "data_length",
4086            |m: &TranslationDataRequest| { &m.data_length },
4087            |m: &mut TranslationDataRequest| { &mut m.data_length },
4088        ));
4089        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4090            "data_offset",
4091            |m: &TranslationDataRequest| { &m.data_offset },
4092            |m: &mut TranslationDataRequest| { &mut m.data_offset },
4093        ));
4094        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TranslationDataRequest>(
4095            "TranslationDataRequest",
4096            fields,
4097            oneofs,
4098        )
4099    }
4100}
4101
4102impl ::protobuf::Message for TranslationDataRequest {
4103    const NAME: &'static str = "TranslationDataRequest";
4104
4105    fn is_initialized(&self) -> bool {
4106        if self.data_length.is_none() {
4107            return false;
4108        }
4109        if self.data_offset.is_none() {
4110            return false;
4111        }
4112        true
4113    }
4114
4115    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4116        while let Some(tag) = is.read_raw_tag_or_eof()? {
4117            match tag {
4118                8 => {
4119                    self.data_length = ::std::option::Option::Some(is.read_uint32()?);
4120                },
4121                16 => {
4122                    self.data_offset = ::std::option::Option::Some(is.read_uint32()?);
4123                },
4124                tag => {
4125                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4126                },
4127            };
4128        }
4129        ::std::result::Result::Ok(())
4130    }
4131
4132    // Compute sizes of nested messages
4133    #[allow(unused_variables)]
4134    fn compute_size(&self) -> u64 {
4135        let mut my_size = 0;
4136        if let Some(v) = self.data_length {
4137            my_size += ::protobuf::rt::uint32_size(1, v);
4138        }
4139        if let Some(v) = self.data_offset {
4140            my_size += ::protobuf::rt::uint32_size(2, v);
4141        }
4142        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4143        self.special_fields.cached_size().set(my_size as u32);
4144        my_size
4145    }
4146
4147    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4148        if let Some(v) = self.data_length {
4149            os.write_uint32(1, v)?;
4150        }
4151        if let Some(v) = self.data_offset {
4152            os.write_uint32(2, v)?;
4153        }
4154        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4155        ::std::result::Result::Ok(())
4156    }
4157
4158    fn special_fields(&self) -> &::protobuf::SpecialFields {
4159        &self.special_fields
4160    }
4161
4162    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4163        &mut self.special_fields
4164    }
4165
4166    fn new() -> TranslationDataRequest {
4167        TranslationDataRequest::new()
4168    }
4169
4170    fn clear(&mut self) {
4171        self.data_length = ::std::option::Option::None;
4172        self.data_offset = ::std::option::Option::None;
4173        self.special_fields.clear();
4174    }
4175
4176    fn default_instance() -> &'static TranslationDataRequest {
4177        static instance: TranslationDataRequest = TranslationDataRequest {
4178            data_length: ::std::option::Option::None,
4179            data_offset: ::std::option::Option::None,
4180            special_fields: ::protobuf::SpecialFields::new(),
4181        };
4182        &instance
4183    }
4184}
4185
4186impl ::protobuf::MessageFull for TranslationDataRequest {
4187    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4188        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4189        descriptor.get(|| file_descriptor().message_by_package_relative_name("TranslationDataRequest").unwrap()).clone()
4190    }
4191}
4192
4193impl ::std::fmt::Display for TranslationDataRequest {
4194    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4195        ::protobuf::text_format::fmt(self, f)
4196    }
4197}
4198
4199impl ::protobuf::reflect::ProtobufValue for TranslationDataRequest {
4200    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4201}
4202
4203// @@protoc_insertion_point(message:hw.trezor.messages.management.TranslationDataAck)
4204#[derive(PartialEq,Clone,Default,Debug)]
4205pub struct TranslationDataAck {
4206    // message fields
4207    // @@protoc_insertion_point(field:hw.trezor.messages.management.TranslationDataAck.data_chunk)
4208    pub data_chunk: ::std::option::Option<::std::vec::Vec<u8>>,
4209    // special fields
4210    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.TranslationDataAck.special_fields)
4211    pub special_fields: ::protobuf::SpecialFields,
4212}
4213
4214impl<'a> ::std::default::Default for &'a TranslationDataAck {
4215    fn default() -> &'a TranslationDataAck {
4216        <TranslationDataAck as ::protobuf::Message>::default_instance()
4217    }
4218}
4219
4220impl TranslationDataAck {
4221    pub fn new() -> TranslationDataAck {
4222        ::std::default::Default::default()
4223    }
4224
4225    // required bytes data_chunk = 1;
4226
4227    pub fn data_chunk(&self) -> &[u8] {
4228        match self.data_chunk.as_ref() {
4229            Some(v) => v,
4230            None => &[],
4231        }
4232    }
4233
4234    pub fn clear_data_chunk(&mut self) {
4235        self.data_chunk = ::std::option::Option::None;
4236    }
4237
4238    pub fn has_data_chunk(&self) -> bool {
4239        self.data_chunk.is_some()
4240    }
4241
4242    // Param is passed by value, moved
4243    pub fn set_data_chunk(&mut self, v: ::std::vec::Vec<u8>) {
4244        self.data_chunk = ::std::option::Option::Some(v);
4245    }
4246
4247    // Mutable pointer to the field.
4248    // If field is not initialized, it is initialized with default value first.
4249    pub fn mut_data_chunk(&mut self) -> &mut ::std::vec::Vec<u8> {
4250        if self.data_chunk.is_none() {
4251            self.data_chunk = ::std::option::Option::Some(::std::vec::Vec::new());
4252        }
4253        self.data_chunk.as_mut().unwrap()
4254    }
4255
4256    // Take field
4257    pub fn take_data_chunk(&mut self) -> ::std::vec::Vec<u8> {
4258        self.data_chunk.take().unwrap_or_else(|| ::std::vec::Vec::new())
4259    }
4260
4261    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4262        let mut fields = ::std::vec::Vec::with_capacity(1);
4263        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4264        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4265            "data_chunk",
4266            |m: &TranslationDataAck| { &m.data_chunk },
4267            |m: &mut TranslationDataAck| { &mut m.data_chunk },
4268        ));
4269        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<TranslationDataAck>(
4270            "TranslationDataAck",
4271            fields,
4272            oneofs,
4273        )
4274    }
4275}
4276
4277impl ::protobuf::Message for TranslationDataAck {
4278    const NAME: &'static str = "TranslationDataAck";
4279
4280    fn is_initialized(&self) -> bool {
4281        if self.data_chunk.is_none() {
4282            return false;
4283        }
4284        true
4285    }
4286
4287    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4288        while let Some(tag) = is.read_raw_tag_or_eof()? {
4289            match tag {
4290                10 => {
4291                    self.data_chunk = ::std::option::Option::Some(is.read_bytes()?);
4292                },
4293                tag => {
4294                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4295                },
4296            };
4297        }
4298        ::std::result::Result::Ok(())
4299    }
4300
4301    // Compute sizes of nested messages
4302    #[allow(unused_variables)]
4303    fn compute_size(&self) -> u64 {
4304        let mut my_size = 0;
4305        if let Some(v) = self.data_chunk.as_ref() {
4306            my_size += ::protobuf::rt::bytes_size(1, &v);
4307        }
4308        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4309        self.special_fields.cached_size().set(my_size as u32);
4310        my_size
4311    }
4312
4313    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4314        if let Some(v) = self.data_chunk.as_ref() {
4315            os.write_bytes(1, v)?;
4316        }
4317        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4318        ::std::result::Result::Ok(())
4319    }
4320
4321    fn special_fields(&self) -> &::protobuf::SpecialFields {
4322        &self.special_fields
4323    }
4324
4325    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4326        &mut self.special_fields
4327    }
4328
4329    fn new() -> TranslationDataAck {
4330        TranslationDataAck::new()
4331    }
4332
4333    fn clear(&mut self) {
4334        self.data_chunk = ::std::option::Option::None;
4335        self.special_fields.clear();
4336    }
4337
4338    fn default_instance() -> &'static TranslationDataAck {
4339        static instance: TranslationDataAck = TranslationDataAck {
4340            data_chunk: ::std::option::Option::None,
4341            special_fields: ::protobuf::SpecialFields::new(),
4342        };
4343        &instance
4344    }
4345}
4346
4347impl ::protobuf::MessageFull for TranslationDataAck {
4348    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4349        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4350        descriptor.get(|| file_descriptor().message_by_package_relative_name("TranslationDataAck").unwrap()).clone()
4351    }
4352}
4353
4354impl ::std::fmt::Display for TranslationDataAck {
4355    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4356        ::protobuf::text_format::fmt(self, f)
4357    }
4358}
4359
4360impl ::protobuf::reflect::ProtobufValue for TranslationDataAck {
4361    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4362}
4363
4364// @@protoc_insertion_point(message:hw.trezor.messages.management.ApplyFlags)
4365#[derive(PartialEq,Clone,Default,Debug)]
4366pub struct ApplyFlags {
4367    // message fields
4368    // @@protoc_insertion_point(field:hw.trezor.messages.management.ApplyFlags.flags)
4369    pub flags: ::std::option::Option<u32>,
4370    // special fields
4371    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ApplyFlags.special_fields)
4372    pub special_fields: ::protobuf::SpecialFields,
4373}
4374
4375impl<'a> ::std::default::Default for &'a ApplyFlags {
4376    fn default() -> &'a ApplyFlags {
4377        <ApplyFlags as ::protobuf::Message>::default_instance()
4378    }
4379}
4380
4381impl ApplyFlags {
4382    pub fn new() -> ApplyFlags {
4383        ::std::default::Default::default()
4384    }
4385
4386    // required uint32 flags = 1;
4387
4388    pub fn flags(&self) -> u32 {
4389        self.flags.unwrap_or(0)
4390    }
4391
4392    pub fn clear_flags(&mut self) {
4393        self.flags = ::std::option::Option::None;
4394    }
4395
4396    pub fn has_flags(&self) -> bool {
4397        self.flags.is_some()
4398    }
4399
4400    // Param is passed by value, moved
4401    pub fn set_flags(&mut self, v: u32) {
4402        self.flags = ::std::option::Option::Some(v);
4403    }
4404
4405    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4406        let mut fields = ::std::vec::Vec::with_capacity(1);
4407        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4408        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4409            "flags",
4410            |m: &ApplyFlags| { &m.flags },
4411            |m: &mut ApplyFlags| { &mut m.flags },
4412        ));
4413        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ApplyFlags>(
4414            "ApplyFlags",
4415            fields,
4416            oneofs,
4417        )
4418    }
4419}
4420
4421impl ::protobuf::Message for ApplyFlags {
4422    const NAME: &'static str = "ApplyFlags";
4423
4424    fn is_initialized(&self) -> bool {
4425        if self.flags.is_none() {
4426            return false;
4427        }
4428        true
4429    }
4430
4431    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4432        while let Some(tag) = is.read_raw_tag_or_eof()? {
4433            match tag {
4434                8 => {
4435                    self.flags = ::std::option::Option::Some(is.read_uint32()?);
4436                },
4437                tag => {
4438                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4439                },
4440            };
4441        }
4442        ::std::result::Result::Ok(())
4443    }
4444
4445    // Compute sizes of nested messages
4446    #[allow(unused_variables)]
4447    fn compute_size(&self) -> u64 {
4448        let mut my_size = 0;
4449        if let Some(v) = self.flags {
4450            my_size += ::protobuf::rt::uint32_size(1, v);
4451        }
4452        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4453        self.special_fields.cached_size().set(my_size as u32);
4454        my_size
4455    }
4456
4457    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4458        if let Some(v) = self.flags {
4459            os.write_uint32(1, v)?;
4460        }
4461        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4462        ::std::result::Result::Ok(())
4463    }
4464
4465    fn special_fields(&self) -> &::protobuf::SpecialFields {
4466        &self.special_fields
4467    }
4468
4469    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4470        &mut self.special_fields
4471    }
4472
4473    fn new() -> ApplyFlags {
4474        ApplyFlags::new()
4475    }
4476
4477    fn clear(&mut self) {
4478        self.flags = ::std::option::Option::None;
4479        self.special_fields.clear();
4480    }
4481
4482    fn default_instance() -> &'static ApplyFlags {
4483        static instance: ApplyFlags = ApplyFlags {
4484            flags: ::std::option::Option::None,
4485            special_fields: ::protobuf::SpecialFields::new(),
4486        };
4487        &instance
4488    }
4489}
4490
4491impl ::protobuf::MessageFull for ApplyFlags {
4492    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4493        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4494        descriptor.get(|| file_descriptor().message_by_package_relative_name("ApplyFlags").unwrap()).clone()
4495    }
4496}
4497
4498impl ::std::fmt::Display for ApplyFlags {
4499    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4500        ::protobuf::text_format::fmt(self, f)
4501    }
4502}
4503
4504impl ::protobuf::reflect::ProtobufValue for ApplyFlags {
4505    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4506}
4507
4508// @@protoc_insertion_point(message:hw.trezor.messages.management.ChangePin)
4509#[derive(PartialEq,Clone,Default,Debug)]
4510pub struct ChangePin {
4511    // message fields
4512    // @@protoc_insertion_point(field:hw.trezor.messages.management.ChangePin.remove)
4513    pub remove: ::std::option::Option<bool>,
4514    // special fields
4515    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ChangePin.special_fields)
4516    pub special_fields: ::protobuf::SpecialFields,
4517}
4518
4519impl<'a> ::std::default::Default for &'a ChangePin {
4520    fn default() -> &'a ChangePin {
4521        <ChangePin as ::protobuf::Message>::default_instance()
4522    }
4523}
4524
4525impl ChangePin {
4526    pub fn new() -> ChangePin {
4527        ::std::default::Default::default()
4528    }
4529
4530    // optional bool remove = 1;
4531
4532    pub fn remove(&self) -> bool {
4533        self.remove.unwrap_or(false)
4534    }
4535
4536    pub fn clear_remove(&mut self) {
4537        self.remove = ::std::option::Option::None;
4538    }
4539
4540    pub fn has_remove(&self) -> bool {
4541        self.remove.is_some()
4542    }
4543
4544    // Param is passed by value, moved
4545    pub fn set_remove(&mut self, v: bool) {
4546        self.remove = ::std::option::Option::Some(v);
4547    }
4548
4549    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4550        let mut fields = ::std::vec::Vec::with_capacity(1);
4551        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4552        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4553            "remove",
4554            |m: &ChangePin| { &m.remove },
4555            |m: &mut ChangePin| { &mut m.remove },
4556        ));
4557        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ChangePin>(
4558            "ChangePin",
4559            fields,
4560            oneofs,
4561        )
4562    }
4563}
4564
4565impl ::protobuf::Message for ChangePin {
4566    const NAME: &'static str = "ChangePin";
4567
4568    fn is_initialized(&self) -> bool {
4569        true
4570    }
4571
4572    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4573        while let Some(tag) = is.read_raw_tag_or_eof()? {
4574            match tag {
4575                8 => {
4576                    self.remove = ::std::option::Option::Some(is.read_bool()?);
4577                },
4578                tag => {
4579                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4580                },
4581            };
4582        }
4583        ::std::result::Result::Ok(())
4584    }
4585
4586    // Compute sizes of nested messages
4587    #[allow(unused_variables)]
4588    fn compute_size(&self) -> u64 {
4589        let mut my_size = 0;
4590        if let Some(v) = self.remove {
4591            my_size += 1 + 1;
4592        }
4593        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4594        self.special_fields.cached_size().set(my_size as u32);
4595        my_size
4596    }
4597
4598    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4599        if let Some(v) = self.remove {
4600            os.write_bool(1, v)?;
4601        }
4602        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4603        ::std::result::Result::Ok(())
4604    }
4605
4606    fn special_fields(&self) -> &::protobuf::SpecialFields {
4607        &self.special_fields
4608    }
4609
4610    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4611        &mut self.special_fields
4612    }
4613
4614    fn new() -> ChangePin {
4615        ChangePin::new()
4616    }
4617
4618    fn clear(&mut self) {
4619        self.remove = ::std::option::Option::None;
4620        self.special_fields.clear();
4621    }
4622
4623    fn default_instance() -> &'static ChangePin {
4624        static instance: ChangePin = ChangePin {
4625            remove: ::std::option::Option::None,
4626            special_fields: ::protobuf::SpecialFields::new(),
4627        };
4628        &instance
4629    }
4630}
4631
4632impl ::protobuf::MessageFull for ChangePin {
4633    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4634        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4635        descriptor.get(|| file_descriptor().message_by_package_relative_name("ChangePin").unwrap()).clone()
4636    }
4637}
4638
4639impl ::std::fmt::Display for ChangePin {
4640    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4641        ::protobuf::text_format::fmt(self, f)
4642    }
4643}
4644
4645impl ::protobuf::reflect::ProtobufValue for ChangePin {
4646    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4647}
4648
4649// @@protoc_insertion_point(message:hw.trezor.messages.management.ChangeWipeCode)
4650#[derive(PartialEq,Clone,Default,Debug)]
4651pub struct ChangeWipeCode {
4652    // message fields
4653    // @@protoc_insertion_point(field:hw.trezor.messages.management.ChangeWipeCode.remove)
4654    pub remove: ::std::option::Option<bool>,
4655    // special fields
4656    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ChangeWipeCode.special_fields)
4657    pub special_fields: ::protobuf::SpecialFields,
4658}
4659
4660impl<'a> ::std::default::Default for &'a ChangeWipeCode {
4661    fn default() -> &'a ChangeWipeCode {
4662        <ChangeWipeCode as ::protobuf::Message>::default_instance()
4663    }
4664}
4665
4666impl ChangeWipeCode {
4667    pub fn new() -> ChangeWipeCode {
4668        ::std::default::Default::default()
4669    }
4670
4671    // optional bool remove = 1;
4672
4673    pub fn remove(&self) -> bool {
4674        self.remove.unwrap_or(false)
4675    }
4676
4677    pub fn clear_remove(&mut self) {
4678        self.remove = ::std::option::Option::None;
4679    }
4680
4681    pub fn has_remove(&self) -> bool {
4682        self.remove.is_some()
4683    }
4684
4685    // Param is passed by value, moved
4686    pub fn set_remove(&mut self, v: bool) {
4687        self.remove = ::std::option::Option::Some(v);
4688    }
4689
4690    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4691        let mut fields = ::std::vec::Vec::with_capacity(1);
4692        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4693        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4694            "remove",
4695            |m: &ChangeWipeCode| { &m.remove },
4696            |m: &mut ChangeWipeCode| { &mut m.remove },
4697        ));
4698        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ChangeWipeCode>(
4699            "ChangeWipeCode",
4700            fields,
4701            oneofs,
4702        )
4703    }
4704}
4705
4706impl ::protobuf::Message for ChangeWipeCode {
4707    const NAME: &'static str = "ChangeWipeCode";
4708
4709    fn is_initialized(&self) -> bool {
4710        true
4711    }
4712
4713    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4714        while let Some(tag) = is.read_raw_tag_or_eof()? {
4715            match tag {
4716                8 => {
4717                    self.remove = ::std::option::Option::Some(is.read_bool()?);
4718                },
4719                tag => {
4720                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4721                },
4722            };
4723        }
4724        ::std::result::Result::Ok(())
4725    }
4726
4727    // Compute sizes of nested messages
4728    #[allow(unused_variables)]
4729    fn compute_size(&self) -> u64 {
4730        let mut my_size = 0;
4731        if let Some(v) = self.remove {
4732            my_size += 1 + 1;
4733        }
4734        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4735        self.special_fields.cached_size().set(my_size as u32);
4736        my_size
4737    }
4738
4739    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4740        if let Some(v) = self.remove {
4741            os.write_bool(1, v)?;
4742        }
4743        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4744        ::std::result::Result::Ok(())
4745    }
4746
4747    fn special_fields(&self) -> &::protobuf::SpecialFields {
4748        &self.special_fields
4749    }
4750
4751    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4752        &mut self.special_fields
4753    }
4754
4755    fn new() -> ChangeWipeCode {
4756        ChangeWipeCode::new()
4757    }
4758
4759    fn clear(&mut self) {
4760        self.remove = ::std::option::Option::None;
4761        self.special_fields.clear();
4762    }
4763
4764    fn default_instance() -> &'static ChangeWipeCode {
4765        static instance: ChangeWipeCode = ChangeWipeCode {
4766            remove: ::std::option::Option::None,
4767            special_fields: ::protobuf::SpecialFields::new(),
4768        };
4769        &instance
4770    }
4771}
4772
4773impl ::protobuf::MessageFull for ChangeWipeCode {
4774    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4775        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4776        descriptor.get(|| file_descriptor().message_by_package_relative_name("ChangeWipeCode").unwrap()).clone()
4777    }
4778}
4779
4780impl ::std::fmt::Display for ChangeWipeCode {
4781    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4782        ::protobuf::text_format::fmt(self, f)
4783    }
4784}
4785
4786impl ::protobuf::reflect::ProtobufValue for ChangeWipeCode {
4787    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4788}
4789
4790// @@protoc_insertion_point(message:hw.trezor.messages.management.SdProtect)
4791#[derive(PartialEq,Clone,Default,Debug)]
4792pub struct SdProtect {
4793    // message fields
4794    // @@protoc_insertion_point(field:hw.trezor.messages.management.SdProtect.operation)
4795    pub operation: ::std::option::Option<::protobuf::EnumOrUnknown<sd_protect::SdProtectOperationType>>,
4796    // special fields
4797    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.SdProtect.special_fields)
4798    pub special_fields: ::protobuf::SpecialFields,
4799}
4800
4801impl<'a> ::std::default::Default for &'a SdProtect {
4802    fn default() -> &'a SdProtect {
4803        <SdProtect as ::protobuf::Message>::default_instance()
4804    }
4805}
4806
4807impl SdProtect {
4808    pub fn new() -> SdProtect {
4809        ::std::default::Default::default()
4810    }
4811
4812    // required .hw.trezor.messages.management.SdProtect.SdProtectOperationType operation = 1;
4813
4814    pub fn operation(&self) -> sd_protect::SdProtectOperationType {
4815        match self.operation {
4816            Some(e) => e.enum_value_or(sd_protect::SdProtectOperationType::DISABLE),
4817            None => sd_protect::SdProtectOperationType::DISABLE,
4818        }
4819    }
4820
4821    pub fn clear_operation(&mut self) {
4822        self.operation = ::std::option::Option::None;
4823    }
4824
4825    pub fn has_operation(&self) -> bool {
4826        self.operation.is_some()
4827    }
4828
4829    // Param is passed by value, moved
4830    pub fn set_operation(&mut self, v: sd_protect::SdProtectOperationType) {
4831        self.operation = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
4832    }
4833
4834    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
4835        let mut fields = ::std::vec::Vec::with_capacity(1);
4836        let mut oneofs = ::std::vec::Vec::with_capacity(0);
4837        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
4838            "operation",
4839            |m: &SdProtect| { &m.operation },
4840            |m: &mut SdProtect| { &mut m.operation },
4841        ));
4842        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SdProtect>(
4843            "SdProtect",
4844            fields,
4845            oneofs,
4846        )
4847    }
4848}
4849
4850impl ::protobuf::Message for SdProtect {
4851    const NAME: &'static str = "SdProtect";
4852
4853    fn is_initialized(&self) -> bool {
4854        if self.operation.is_none() {
4855            return false;
4856        }
4857        true
4858    }
4859
4860    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
4861        while let Some(tag) = is.read_raw_tag_or_eof()? {
4862            match tag {
4863                8 => {
4864                    self.operation = ::std::option::Option::Some(is.read_enum_or_unknown()?);
4865                },
4866                tag => {
4867                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
4868                },
4869            };
4870        }
4871        ::std::result::Result::Ok(())
4872    }
4873
4874    // Compute sizes of nested messages
4875    #[allow(unused_variables)]
4876    fn compute_size(&self) -> u64 {
4877        let mut my_size = 0;
4878        if let Some(v) = self.operation {
4879            my_size += ::protobuf::rt::int32_size(1, v.value());
4880        }
4881        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
4882        self.special_fields.cached_size().set(my_size as u32);
4883        my_size
4884    }
4885
4886    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
4887        if let Some(v) = self.operation {
4888            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
4889        }
4890        os.write_unknown_fields(self.special_fields.unknown_fields())?;
4891        ::std::result::Result::Ok(())
4892    }
4893
4894    fn special_fields(&self) -> &::protobuf::SpecialFields {
4895        &self.special_fields
4896    }
4897
4898    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
4899        &mut self.special_fields
4900    }
4901
4902    fn new() -> SdProtect {
4903        SdProtect::new()
4904    }
4905
4906    fn clear(&mut self) {
4907        self.operation = ::std::option::Option::None;
4908        self.special_fields.clear();
4909    }
4910
4911    fn default_instance() -> &'static SdProtect {
4912        static instance: SdProtect = SdProtect {
4913            operation: ::std::option::Option::None,
4914            special_fields: ::protobuf::SpecialFields::new(),
4915        };
4916        &instance
4917    }
4918}
4919
4920impl ::protobuf::MessageFull for SdProtect {
4921    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
4922        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
4923        descriptor.get(|| file_descriptor().message_by_package_relative_name("SdProtect").unwrap()).clone()
4924    }
4925}
4926
4927impl ::std::fmt::Display for SdProtect {
4928    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
4929        ::protobuf::text_format::fmt(self, f)
4930    }
4931}
4932
4933impl ::protobuf::reflect::ProtobufValue for SdProtect {
4934    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
4935}
4936
4937/// Nested message and enums of message `SdProtect`
4938pub mod sd_protect {
4939    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
4940    // @@protoc_insertion_point(enum:hw.trezor.messages.management.SdProtect.SdProtectOperationType)
4941    pub enum SdProtectOperationType {
4942        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SdProtect.SdProtectOperationType.DISABLE)
4943        DISABLE = 0,
4944        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SdProtect.SdProtectOperationType.ENABLE)
4945        ENABLE = 1,
4946        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SdProtect.SdProtectOperationType.REFRESH)
4947        REFRESH = 2,
4948    }
4949
4950    impl ::protobuf::Enum for SdProtectOperationType {
4951        const NAME: &'static str = "SdProtectOperationType";
4952
4953        fn value(&self) -> i32 {
4954            *self as i32
4955        }
4956
4957        fn from_i32(value: i32) -> ::std::option::Option<SdProtectOperationType> {
4958            match value {
4959                0 => ::std::option::Option::Some(SdProtectOperationType::DISABLE),
4960                1 => ::std::option::Option::Some(SdProtectOperationType::ENABLE),
4961                2 => ::std::option::Option::Some(SdProtectOperationType::REFRESH),
4962                _ => ::std::option::Option::None
4963            }
4964        }
4965
4966        fn from_str(str: &str) -> ::std::option::Option<SdProtectOperationType> {
4967            match str {
4968                "DISABLE" => ::std::option::Option::Some(SdProtectOperationType::DISABLE),
4969                "ENABLE" => ::std::option::Option::Some(SdProtectOperationType::ENABLE),
4970                "REFRESH" => ::std::option::Option::Some(SdProtectOperationType::REFRESH),
4971                _ => ::std::option::Option::None
4972            }
4973        }
4974
4975        const VALUES: &'static [SdProtectOperationType] = &[
4976            SdProtectOperationType::DISABLE,
4977            SdProtectOperationType::ENABLE,
4978            SdProtectOperationType::REFRESH,
4979        ];
4980    }
4981
4982    impl ::protobuf::EnumFull for SdProtectOperationType {
4983        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
4984            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
4985            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("SdProtect.SdProtectOperationType").unwrap()).clone()
4986        }
4987
4988        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
4989            let index = *self as usize;
4990            Self::enum_descriptor().value_by_index(index)
4991        }
4992    }
4993
4994    impl ::std::default::Default for SdProtectOperationType {
4995        fn default() -> Self {
4996            SdProtectOperationType::DISABLE
4997        }
4998    }
4999
5000    impl SdProtectOperationType {
5001        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
5002            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<SdProtectOperationType>("SdProtect.SdProtectOperationType")
5003        }
5004    }
5005}
5006
5007// @@protoc_insertion_point(message:hw.trezor.messages.management.Ping)
5008#[derive(PartialEq,Clone,Default,Debug)]
5009pub struct Ping {
5010    // message fields
5011    // @@protoc_insertion_point(field:hw.trezor.messages.management.Ping.message)
5012    pub message: ::std::option::Option<::std::string::String>,
5013    // @@protoc_insertion_point(field:hw.trezor.messages.management.Ping.button_protection)
5014    pub button_protection: ::std::option::Option<bool>,
5015    // special fields
5016    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Ping.special_fields)
5017    pub special_fields: ::protobuf::SpecialFields,
5018}
5019
5020impl<'a> ::std::default::Default for &'a Ping {
5021    fn default() -> &'a Ping {
5022        <Ping as ::protobuf::Message>::default_instance()
5023    }
5024}
5025
5026impl Ping {
5027    pub fn new() -> Ping {
5028        ::std::default::Default::default()
5029    }
5030
5031    // optional string message = 1;
5032
5033    pub fn message(&self) -> &str {
5034        match self.message.as_ref() {
5035            Some(v) => v,
5036            None => "",
5037        }
5038    }
5039
5040    pub fn clear_message(&mut self) {
5041        self.message = ::std::option::Option::None;
5042    }
5043
5044    pub fn has_message(&self) -> bool {
5045        self.message.is_some()
5046    }
5047
5048    // Param is passed by value, moved
5049    pub fn set_message(&mut self, v: ::std::string::String) {
5050        self.message = ::std::option::Option::Some(v);
5051    }
5052
5053    // Mutable pointer to the field.
5054    // If field is not initialized, it is initialized with default value first.
5055    pub fn mut_message(&mut self) -> &mut ::std::string::String {
5056        if self.message.is_none() {
5057            self.message = ::std::option::Option::Some(::std::string::String::new());
5058        }
5059        self.message.as_mut().unwrap()
5060    }
5061
5062    // Take field
5063    pub fn take_message(&mut self) -> ::std::string::String {
5064        self.message.take().unwrap_or_else(|| ::std::string::String::new())
5065    }
5066
5067    // optional bool button_protection = 2;
5068
5069    pub fn button_protection(&self) -> bool {
5070        self.button_protection.unwrap_or(false)
5071    }
5072
5073    pub fn clear_button_protection(&mut self) {
5074        self.button_protection = ::std::option::Option::None;
5075    }
5076
5077    pub fn has_button_protection(&self) -> bool {
5078        self.button_protection.is_some()
5079    }
5080
5081    // Param is passed by value, moved
5082    pub fn set_button_protection(&mut self, v: bool) {
5083        self.button_protection = ::std::option::Option::Some(v);
5084    }
5085
5086    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5087        let mut fields = ::std::vec::Vec::with_capacity(2);
5088        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5089        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5090            "message",
5091            |m: &Ping| { &m.message },
5092            |m: &mut Ping| { &mut m.message },
5093        ));
5094        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5095            "button_protection",
5096            |m: &Ping| { &m.button_protection },
5097            |m: &mut Ping| { &mut m.button_protection },
5098        ));
5099        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Ping>(
5100            "Ping",
5101            fields,
5102            oneofs,
5103        )
5104    }
5105}
5106
5107impl ::protobuf::Message for Ping {
5108    const NAME: &'static str = "Ping";
5109
5110    fn is_initialized(&self) -> bool {
5111        true
5112    }
5113
5114    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5115        while let Some(tag) = is.read_raw_tag_or_eof()? {
5116            match tag {
5117                10 => {
5118                    self.message = ::std::option::Option::Some(is.read_string()?);
5119                },
5120                16 => {
5121                    self.button_protection = ::std::option::Option::Some(is.read_bool()?);
5122                },
5123                tag => {
5124                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5125                },
5126            };
5127        }
5128        ::std::result::Result::Ok(())
5129    }
5130
5131    // Compute sizes of nested messages
5132    #[allow(unused_variables)]
5133    fn compute_size(&self) -> u64 {
5134        let mut my_size = 0;
5135        if let Some(v) = self.message.as_ref() {
5136            my_size += ::protobuf::rt::string_size(1, &v);
5137        }
5138        if let Some(v) = self.button_protection {
5139            my_size += 1 + 1;
5140        }
5141        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5142        self.special_fields.cached_size().set(my_size as u32);
5143        my_size
5144    }
5145
5146    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5147        if let Some(v) = self.message.as_ref() {
5148            os.write_string(1, v)?;
5149        }
5150        if let Some(v) = self.button_protection {
5151            os.write_bool(2, v)?;
5152        }
5153        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5154        ::std::result::Result::Ok(())
5155    }
5156
5157    fn special_fields(&self) -> &::protobuf::SpecialFields {
5158        &self.special_fields
5159    }
5160
5161    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5162        &mut self.special_fields
5163    }
5164
5165    fn new() -> Ping {
5166        Ping::new()
5167    }
5168
5169    fn clear(&mut self) {
5170        self.message = ::std::option::Option::None;
5171        self.button_protection = ::std::option::Option::None;
5172        self.special_fields.clear();
5173    }
5174
5175    fn default_instance() -> &'static Ping {
5176        static instance: Ping = Ping {
5177            message: ::std::option::Option::None,
5178            button_protection: ::std::option::Option::None,
5179            special_fields: ::protobuf::SpecialFields::new(),
5180        };
5181        &instance
5182    }
5183}
5184
5185impl ::protobuf::MessageFull for Ping {
5186    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5187        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5188        descriptor.get(|| file_descriptor().message_by_package_relative_name("Ping").unwrap()).clone()
5189    }
5190}
5191
5192impl ::std::fmt::Display for Ping {
5193    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5194        ::protobuf::text_format::fmt(self, f)
5195    }
5196}
5197
5198impl ::protobuf::reflect::ProtobufValue for Ping {
5199    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5200}
5201
5202// @@protoc_insertion_point(message:hw.trezor.messages.management.Cancel)
5203#[derive(PartialEq,Clone,Default,Debug)]
5204pub struct Cancel {
5205    // special fields
5206    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Cancel.special_fields)
5207    pub special_fields: ::protobuf::SpecialFields,
5208}
5209
5210impl<'a> ::std::default::Default for &'a Cancel {
5211    fn default() -> &'a Cancel {
5212        <Cancel as ::protobuf::Message>::default_instance()
5213    }
5214}
5215
5216impl Cancel {
5217    pub fn new() -> Cancel {
5218        ::std::default::Default::default()
5219    }
5220
5221    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5222        let mut fields = ::std::vec::Vec::with_capacity(0);
5223        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5224        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Cancel>(
5225            "Cancel",
5226            fields,
5227            oneofs,
5228        )
5229    }
5230}
5231
5232impl ::protobuf::Message for Cancel {
5233    const NAME: &'static str = "Cancel";
5234
5235    fn is_initialized(&self) -> bool {
5236        true
5237    }
5238
5239    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5240        while let Some(tag) = is.read_raw_tag_or_eof()? {
5241            match tag {
5242                tag => {
5243                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5244                },
5245            };
5246        }
5247        ::std::result::Result::Ok(())
5248    }
5249
5250    // Compute sizes of nested messages
5251    #[allow(unused_variables)]
5252    fn compute_size(&self) -> u64 {
5253        let mut my_size = 0;
5254        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5255        self.special_fields.cached_size().set(my_size as u32);
5256        my_size
5257    }
5258
5259    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5260        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5261        ::std::result::Result::Ok(())
5262    }
5263
5264    fn special_fields(&self) -> &::protobuf::SpecialFields {
5265        &self.special_fields
5266    }
5267
5268    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5269        &mut self.special_fields
5270    }
5271
5272    fn new() -> Cancel {
5273        Cancel::new()
5274    }
5275
5276    fn clear(&mut self) {
5277        self.special_fields.clear();
5278    }
5279
5280    fn default_instance() -> &'static Cancel {
5281        static instance: Cancel = Cancel {
5282            special_fields: ::protobuf::SpecialFields::new(),
5283        };
5284        &instance
5285    }
5286}
5287
5288impl ::protobuf::MessageFull for Cancel {
5289    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5290        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5291        descriptor.get(|| file_descriptor().message_by_package_relative_name("Cancel").unwrap()).clone()
5292    }
5293}
5294
5295impl ::std::fmt::Display for Cancel {
5296    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5297        ::protobuf::text_format::fmt(self, f)
5298    }
5299}
5300
5301impl ::protobuf::reflect::ProtobufValue for Cancel {
5302    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5303}
5304
5305// @@protoc_insertion_point(message:hw.trezor.messages.management.GetEntropy)
5306#[derive(PartialEq,Clone,Default,Debug)]
5307pub struct GetEntropy {
5308    // message fields
5309    // @@protoc_insertion_point(field:hw.trezor.messages.management.GetEntropy.size)
5310    pub size: ::std::option::Option<u32>,
5311    // special fields
5312    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.GetEntropy.special_fields)
5313    pub special_fields: ::protobuf::SpecialFields,
5314}
5315
5316impl<'a> ::std::default::Default for &'a GetEntropy {
5317    fn default() -> &'a GetEntropy {
5318        <GetEntropy as ::protobuf::Message>::default_instance()
5319    }
5320}
5321
5322impl GetEntropy {
5323    pub fn new() -> GetEntropy {
5324        ::std::default::Default::default()
5325    }
5326
5327    // required uint32 size = 1;
5328
5329    pub fn size(&self) -> u32 {
5330        self.size.unwrap_or(0)
5331    }
5332
5333    pub fn clear_size(&mut self) {
5334        self.size = ::std::option::Option::None;
5335    }
5336
5337    pub fn has_size(&self) -> bool {
5338        self.size.is_some()
5339    }
5340
5341    // Param is passed by value, moved
5342    pub fn set_size(&mut self, v: u32) {
5343        self.size = ::std::option::Option::Some(v);
5344    }
5345
5346    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5347        let mut fields = ::std::vec::Vec::with_capacity(1);
5348        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5349        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5350            "size",
5351            |m: &GetEntropy| { &m.size },
5352            |m: &mut GetEntropy| { &mut m.size },
5353        ));
5354        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetEntropy>(
5355            "GetEntropy",
5356            fields,
5357            oneofs,
5358        )
5359    }
5360}
5361
5362impl ::protobuf::Message for GetEntropy {
5363    const NAME: &'static str = "GetEntropy";
5364
5365    fn is_initialized(&self) -> bool {
5366        if self.size.is_none() {
5367            return false;
5368        }
5369        true
5370    }
5371
5372    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5373        while let Some(tag) = is.read_raw_tag_or_eof()? {
5374            match tag {
5375                8 => {
5376                    self.size = ::std::option::Option::Some(is.read_uint32()?);
5377                },
5378                tag => {
5379                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5380                },
5381            };
5382        }
5383        ::std::result::Result::Ok(())
5384    }
5385
5386    // Compute sizes of nested messages
5387    #[allow(unused_variables)]
5388    fn compute_size(&self) -> u64 {
5389        let mut my_size = 0;
5390        if let Some(v) = self.size {
5391            my_size += ::protobuf::rt::uint32_size(1, v);
5392        }
5393        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5394        self.special_fields.cached_size().set(my_size as u32);
5395        my_size
5396    }
5397
5398    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5399        if let Some(v) = self.size {
5400            os.write_uint32(1, v)?;
5401        }
5402        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5403        ::std::result::Result::Ok(())
5404    }
5405
5406    fn special_fields(&self) -> &::protobuf::SpecialFields {
5407        &self.special_fields
5408    }
5409
5410    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5411        &mut self.special_fields
5412    }
5413
5414    fn new() -> GetEntropy {
5415        GetEntropy::new()
5416    }
5417
5418    fn clear(&mut self) {
5419        self.size = ::std::option::Option::None;
5420        self.special_fields.clear();
5421    }
5422
5423    fn default_instance() -> &'static GetEntropy {
5424        static instance: GetEntropy = GetEntropy {
5425            size: ::std::option::Option::None,
5426            special_fields: ::protobuf::SpecialFields::new(),
5427        };
5428        &instance
5429    }
5430}
5431
5432impl ::protobuf::MessageFull for GetEntropy {
5433    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5434        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5435        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetEntropy").unwrap()).clone()
5436    }
5437}
5438
5439impl ::std::fmt::Display for GetEntropy {
5440    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5441        ::protobuf::text_format::fmt(self, f)
5442    }
5443}
5444
5445impl ::protobuf::reflect::ProtobufValue for GetEntropy {
5446    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5447}
5448
5449// @@protoc_insertion_point(message:hw.trezor.messages.management.Entropy)
5450#[derive(PartialEq,Clone,Default,Debug)]
5451pub struct Entropy {
5452    // message fields
5453    // @@protoc_insertion_point(field:hw.trezor.messages.management.Entropy.entropy)
5454    pub entropy: ::std::option::Option<::std::vec::Vec<u8>>,
5455    // special fields
5456    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Entropy.special_fields)
5457    pub special_fields: ::protobuf::SpecialFields,
5458}
5459
5460impl<'a> ::std::default::Default for &'a Entropy {
5461    fn default() -> &'a Entropy {
5462        <Entropy as ::protobuf::Message>::default_instance()
5463    }
5464}
5465
5466impl Entropy {
5467    pub fn new() -> Entropy {
5468        ::std::default::Default::default()
5469    }
5470
5471    // required bytes entropy = 1;
5472
5473    pub fn entropy(&self) -> &[u8] {
5474        match self.entropy.as_ref() {
5475            Some(v) => v,
5476            None => &[],
5477        }
5478    }
5479
5480    pub fn clear_entropy(&mut self) {
5481        self.entropy = ::std::option::Option::None;
5482    }
5483
5484    pub fn has_entropy(&self) -> bool {
5485        self.entropy.is_some()
5486    }
5487
5488    // Param is passed by value, moved
5489    pub fn set_entropy(&mut self, v: ::std::vec::Vec<u8>) {
5490        self.entropy = ::std::option::Option::Some(v);
5491    }
5492
5493    // Mutable pointer to the field.
5494    // If field is not initialized, it is initialized with default value first.
5495    pub fn mut_entropy(&mut self) -> &mut ::std::vec::Vec<u8> {
5496        if self.entropy.is_none() {
5497            self.entropy = ::std::option::Option::Some(::std::vec::Vec::new());
5498        }
5499        self.entropy.as_mut().unwrap()
5500    }
5501
5502    // Take field
5503    pub fn take_entropy(&mut self) -> ::std::vec::Vec<u8> {
5504        self.entropy.take().unwrap_or_else(|| ::std::vec::Vec::new())
5505    }
5506
5507    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5508        let mut fields = ::std::vec::Vec::with_capacity(1);
5509        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5510        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5511            "entropy",
5512            |m: &Entropy| { &m.entropy },
5513            |m: &mut Entropy| { &mut m.entropy },
5514        ));
5515        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Entropy>(
5516            "Entropy",
5517            fields,
5518            oneofs,
5519        )
5520    }
5521}
5522
5523impl ::protobuf::Message for Entropy {
5524    const NAME: &'static str = "Entropy";
5525
5526    fn is_initialized(&self) -> bool {
5527        if self.entropy.is_none() {
5528            return false;
5529        }
5530        true
5531    }
5532
5533    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5534        while let Some(tag) = is.read_raw_tag_or_eof()? {
5535            match tag {
5536                10 => {
5537                    self.entropy = ::std::option::Option::Some(is.read_bytes()?);
5538                },
5539                tag => {
5540                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5541                },
5542            };
5543        }
5544        ::std::result::Result::Ok(())
5545    }
5546
5547    // Compute sizes of nested messages
5548    #[allow(unused_variables)]
5549    fn compute_size(&self) -> u64 {
5550        let mut my_size = 0;
5551        if let Some(v) = self.entropy.as_ref() {
5552            my_size += ::protobuf::rt::bytes_size(1, &v);
5553        }
5554        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5555        self.special_fields.cached_size().set(my_size as u32);
5556        my_size
5557    }
5558
5559    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5560        if let Some(v) = self.entropy.as_ref() {
5561            os.write_bytes(1, v)?;
5562        }
5563        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5564        ::std::result::Result::Ok(())
5565    }
5566
5567    fn special_fields(&self) -> &::protobuf::SpecialFields {
5568        &self.special_fields
5569    }
5570
5571    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5572        &mut self.special_fields
5573    }
5574
5575    fn new() -> Entropy {
5576        Entropy::new()
5577    }
5578
5579    fn clear(&mut self) {
5580        self.entropy = ::std::option::Option::None;
5581        self.special_fields.clear();
5582    }
5583
5584    fn default_instance() -> &'static Entropy {
5585        static instance: Entropy = Entropy {
5586            entropy: ::std::option::Option::None,
5587            special_fields: ::protobuf::SpecialFields::new(),
5588        };
5589        &instance
5590    }
5591}
5592
5593impl ::protobuf::MessageFull for Entropy {
5594    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5595        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5596        descriptor.get(|| file_descriptor().message_by_package_relative_name("Entropy").unwrap()).clone()
5597    }
5598}
5599
5600impl ::std::fmt::Display for Entropy {
5601    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5602        ::protobuf::text_format::fmt(self, f)
5603    }
5604}
5605
5606impl ::protobuf::reflect::ProtobufValue for Entropy {
5607    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5608}
5609
5610// @@protoc_insertion_point(message:hw.trezor.messages.management.GetFirmwareHash)
5611#[derive(PartialEq,Clone,Default,Debug)]
5612pub struct GetFirmwareHash {
5613    // message fields
5614    // @@protoc_insertion_point(field:hw.trezor.messages.management.GetFirmwareHash.challenge)
5615    pub challenge: ::std::option::Option<::std::vec::Vec<u8>>,
5616    // special fields
5617    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.GetFirmwareHash.special_fields)
5618    pub special_fields: ::protobuf::SpecialFields,
5619}
5620
5621impl<'a> ::std::default::Default for &'a GetFirmwareHash {
5622    fn default() -> &'a GetFirmwareHash {
5623        <GetFirmwareHash as ::protobuf::Message>::default_instance()
5624    }
5625}
5626
5627impl GetFirmwareHash {
5628    pub fn new() -> GetFirmwareHash {
5629        ::std::default::Default::default()
5630    }
5631
5632    // optional bytes challenge = 1;
5633
5634    pub fn challenge(&self) -> &[u8] {
5635        match self.challenge.as_ref() {
5636            Some(v) => v,
5637            None => &[],
5638        }
5639    }
5640
5641    pub fn clear_challenge(&mut self) {
5642        self.challenge = ::std::option::Option::None;
5643    }
5644
5645    pub fn has_challenge(&self) -> bool {
5646        self.challenge.is_some()
5647    }
5648
5649    // Param is passed by value, moved
5650    pub fn set_challenge(&mut self, v: ::std::vec::Vec<u8>) {
5651        self.challenge = ::std::option::Option::Some(v);
5652    }
5653
5654    // Mutable pointer to the field.
5655    // If field is not initialized, it is initialized with default value first.
5656    pub fn mut_challenge(&mut self) -> &mut ::std::vec::Vec<u8> {
5657        if self.challenge.is_none() {
5658            self.challenge = ::std::option::Option::Some(::std::vec::Vec::new());
5659        }
5660        self.challenge.as_mut().unwrap()
5661    }
5662
5663    // Take field
5664    pub fn take_challenge(&mut self) -> ::std::vec::Vec<u8> {
5665        self.challenge.take().unwrap_or_else(|| ::std::vec::Vec::new())
5666    }
5667
5668    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5669        let mut fields = ::std::vec::Vec::with_capacity(1);
5670        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5671        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5672            "challenge",
5673            |m: &GetFirmwareHash| { &m.challenge },
5674            |m: &mut GetFirmwareHash| { &mut m.challenge },
5675        ));
5676        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetFirmwareHash>(
5677            "GetFirmwareHash",
5678            fields,
5679            oneofs,
5680        )
5681    }
5682}
5683
5684impl ::protobuf::Message for GetFirmwareHash {
5685    const NAME: &'static str = "GetFirmwareHash";
5686
5687    fn is_initialized(&self) -> bool {
5688        true
5689    }
5690
5691    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5692        while let Some(tag) = is.read_raw_tag_or_eof()? {
5693            match tag {
5694                10 => {
5695                    self.challenge = ::std::option::Option::Some(is.read_bytes()?);
5696                },
5697                tag => {
5698                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5699                },
5700            };
5701        }
5702        ::std::result::Result::Ok(())
5703    }
5704
5705    // Compute sizes of nested messages
5706    #[allow(unused_variables)]
5707    fn compute_size(&self) -> u64 {
5708        let mut my_size = 0;
5709        if let Some(v) = self.challenge.as_ref() {
5710            my_size += ::protobuf::rt::bytes_size(1, &v);
5711        }
5712        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5713        self.special_fields.cached_size().set(my_size as u32);
5714        my_size
5715    }
5716
5717    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5718        if let Some(v) = self.challenge.as_ref() {
5719            os.write_bytes(1, v)?;
5720        }
5721        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5722        ::std::result::Result::Ok(())
5723    }
5724
5725    fn special_fields(&self) -> &::protobuf::SpecialFields {
5726        &self.special_fields
5727    }
5728
5729    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5730        &mut self.special_fields
5731    }
5732
5733    fn new() -> GetFirmwareHash {
5734        GetFirmwareHash::new()
5735    }
5736
5737    fn clear(&mut self) {
5738        self.challenge = ::std::option::Option::None;
5739        self.special_fields.clear();
5740    }
5741
5742    fn default_instance() -> &'static GetFirmwareHash {
5743        static instance: GetFirmwareHash = GetFirmwareHash {
5744            challenge: ::std::option::Option::None,
5745            special_fields: ::protobuf::SpecialFields::new(),
5746        };
5747        &instance
5748    }
5749}
5750
5751impl ::protobuf::MessageFull for GetFirmwareHash {
5752    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5753        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5754        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetFirmwareHash").unwrap()).clone()
5755    }
5756}
5757
5758impl ::std::fmt::Display for GetFirmwareHash {
5759    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5760        ::protobuf::text_format::fmt(self, f)
5761    }
5762}
5763
5764impl ::protobuf::reflect::ProtobufValue for GetFirmwareHash {
5765    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5766}
5767
5768// @@protoc_insertion_point(message:hw.trezor.messages.management.FirmwareHash)
5769#[derive(PartialEq,Clone,Default,Debug)]
5770pub struct FirmwareHash {
5771    // message fields
5772    // @@protoc_insertion_point(field:hw.trezor.messages.management.FirmwareHash.hash)
5773    pub hash: ::std::option::Option<::std::vec::Vec<u8>>,
5774    // special fields
5775    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.FirmwareHash.special_fields)
5776    pub special_fields: ::protobuf::SpecialFields,
5777}
5778
5779impl<'a> ::std::default::Default for &'a FirmwareHash {
5780    fn default() -> &'a FirmwareHash {
5781        <FirmwareHash as ::protobuf::Message>::default_instance()
5782    }
5783}
5784
5785impl FirmwareHash {
5786    pub fn new() -> FirmwareHash {
5787        ::std::default::Default::default()
5788    }
5789
5790    // required bytes hash = 1;
5791
5792    pub fn hash(&self) -> &[u8] {
5793        match self.hash.as_ref() {
5794            Some(v) => v,
5795            None => &[],
5796        }
5797    }
5798
5799    pub fn clear_hash(&mut self) {
5800        self.hash = ::std::option::Option::None;
5801    }
5802
5803    pub fn has_hash(&self) -> bool {
5804        self.hash.is_some()
5805    }
5806
5807    // Param is passed by value, moved
5808    pub fn set_hash(&mut self, v: ::std::vec::Vec<u8>) {
5809        self.hash = ::std::option::Option::Some(v);
5810    }
5811
5812    // Mutable pointer to the field.
5813    // If field is not initialized, it is initialized with default value first.
5814    pub fn mut_hash(&mut self) -> &mut ::std::vec::Vec<u8> {
5815        if self.hash.is_none() {
5816            self.hash = ::std::option::Option::Some(::std::vec::Vec::new());
5817        }
5818        self.hash.as_mut().unwrap()
5819    }
5820
5821    // Take field
5822    pub fn take_hash(&mut self) -> ::std::vec::Vec<u8> {
5823        self.hash.take().unwrap_or_else(|| ::std::vec::Vec::new())
5824    }
5825
5826    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5827        let mut fields = ::std::vec::Vec::with_capacity(1);
5828        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5829        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5830            "hash",
5831            |m: &FirmwareHash| { &m.hash },
5832            |m: &mut FirmwareHash| { &mut m.hash },
5833        ));
5834        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<FirmwareHash>(
5835            "FirmwareHash",
5836            fields,
5837            oneofs,
5838        )
5839    }
5840}
5841
5842impl ::protobuf::Message for FirmwareHash {
5843    const NAME: &'static str = "FirmwareHash";
5844
5845    fn is_initialized(&self) -> bool {
5846        if self.hash.is_none() {
5847            return false;
5848        }
5849        true
5850    }
5851
5852    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
5853        while let Some(tag) = is.read_raw_tag_or_eof()? {
5854            match tag {
5855                10 => {
5856                    self.hash = ::std::option::Option::Some(is.read_bytes()?);
5857                },
5858                tag => {
5859                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
5860                },
5861            };
5862        }
5863        ::std::result::Result::Ok(())
5864    }
5865
5866    // Compute sizes of nested messages
5867    #[allow(unused_variables)]
5868    fn compute_size(&self) -> u64 {
5869        let mut my_size = 0;
5870        if let Some(v) = self.hash.as_ref() {
5871            my_size += ::protobuf::rt::bytes_size(1, &v);
5872        }
5873        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
5874        self.special_fields.cached_size().set(my_size as u32);
5875        my_size
5876    }
5877
5878    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
5879        if let Some(v) = self.hash.as_ref() {
5880            os.write_bytes(1, v)?;
5881        }
5882        os.write_unknown_fields(self.special_fields.unknown_fields())?;
5883        ::std::result::Result::Ok(())
5884    }
5885
5886    fn special_fields(&self) -> &::protobuf::SpecialFields {
5887        &self.special_fields
5888    }
5889
5890    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
5891        &mut self.special_fields
5892    }
5893
5894    fn new() -> FirmwareHash {
5895        FirmwareHash::new()
5896    }
5897
5898    fn clear(&mut self) {
5899        self.hash = ::std::option::Option::None;
5900        self.special_fields.clear();
5901    }
5902
5903    fn default_instance() -> &'static FirmwareHash {
5904        static instance: FirmwareHash = FirmwareHash {
5905            hash: ::std::option::Option::None,
5906            special_fields: ::protobuf::SpecialFields::new(),
5907        };
5908        &instance
5909    }
5910}
5911
5912impl ::protobuf::MessageFull for FirmwareHash {
5913    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
5914        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
5915        descriptor.get(|| file_descriptor().message_by_package_relative_name("FirmwareHash").unwrap()).clone()
5916    }
5917}
5918
5919impl ::std::fmt::Display for FirmwareHash {
5920    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
5921        ::protobuf::text_format::fmt(self, f)
5922    }
5923}
5924
5925impl ::protobuf::reflect::ProtobufValue for FirmwareHash {
5926    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
5927}
5928
5929// @@protoc_insertion_point(message:hw.trezor.messages.management.AuthenticateDevice)
5930#[derive(PartialEq,Clone,Default,Debug)]
5931pub struct AuthenticateDevice {
5932    // message fields
5933    // @@protoc_insertion_point(field:hw.trezor.messages.management.AuthenticateDevice.challenge)
5934    pub challenge: ::std::option::Option<::std::vec::Vec<u8>>,
5935    // special fields
5936    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.AuthenticateDevice.special_fields)
5937    pub special_fields: ::protobuf::SpecialFields,
5938}
5939
5940impl<'a> ::std::default::Default for &'a AuthenticateDevice {
5941    fn default() -> &'a AuthenticateDevice {
5942        <AuthenticateDevice as ::protobuf::Message>::default_instance()
5943    }
5944}
5945
5946impl AuthenticateDevice {
5947    pub fn new() -> AuthenticateDevice {
5948        ::std::default::Default::default()
5949    }
5950
5951    // required bytes challenge = 1;
5952
5953    pub fn challenge(&self) -> &[u8] {
5954        match self.challenge.as_ref() {
5955            Some(v) => v,
5956            None => &[],
5957        }
5958    }
5959
5960    pub fn clear_challenge(&mut self) {
5961        self.challenge = ::std::option::Option::None;
5962    }
5963
5964    pub fn has_challenge(&self) -> bool {
5965        self.challenge.is_some()
5966    }
5967
5968    // Param is passed by value, moved
5969    pub fn set_challenge(&mut self, v: ::std::vec::Vec<u8>) {
5970        self.challenge = ::std::option::Option::Some(v);
5971    }
5972
5973    // Mutable pointer to the field.
5974    // If field is not initialized, it is initialized with default value first.
5975    pub fn mut_challenge(&mut self) -> &mut ::std::vec::Vec<u8> {
5976        if self.challenge.is_none() {
5977            self.challenge = ::std::option::Option::Some(::std::vec::Vec::new());
5978        }
5979        self.challenge.as_mut().unwrap()
5980    }
5981
5982    // Take field
5983    pub fn take_challenge(&mut self) -> ::std::vec::Vec<u8> {
5984        self.challenge.take().unwrap_or_else(|| ::std::vec::Vec::new())
5985    }
5986
5987    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
5988        let mut fields = ::std::vec::Vec::with_capacity(1);
5989        let mut oneofs = ::std::vec::Vec::with_capacity(0);
5990        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
5991            "challenge",
5992            |m: &AuthenticateDevice| { &m.challenge },
5993            |m: &mut AuthenticateDevice| { &mut m.challenge },
5994        ));
5995        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AuthenticateDevice>(
5996            "AuthenticateDevice",
5997            fields,
5998            oneofs,
5999        )
6000    }
6001}
6002
6003impl ::protobuf::Message for AuthenticateDevice {
6004    const NAME: &'static str = "AuthenticateDevice";
6005
6006    fn is_initialized(&self) -> bool {
6007        if self.challenge.is_none() {
6008            return false;
6009        }
6010        true
6011    }
6012
6013    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
6014        while let Some(tag) = is.read_raw_tag_or_eof()? {
6015            match tag {
6016                10 => {
6017                    self.challenge = ::std::option::Option::Some(is.read_bytes()?);
6018                },
6019                tag => {
6020                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6021                },
6022            };
6023        }
6024        ::std::result::Result::Ok(())
6025    }
6026
6027    // Compute sizes of nested messages
6028    #[allow(unused_variables)]
6029    fn compute_size(&self) -> u64 {
6030        let mut my_size = 0;
6031        if let Some(v) = self.challenge.as_ref() {
6032            my_size += ::protobuf::rt::bytes_size(1, &v);
6033        }
6034        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6035        self.special_fields.cached_size().set(my_size as u32);
6036        my_size
6037    }
6038
6039    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
6040        if let Some(v) = self.challenge.as_ref() {
6041            os.write_bytes(1, v)?;
6042        }
6043        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6044        ::std::result::Result::Ok(())
6045    }
6046
6047    fn special_fields(&self) -> &::protobuf::SpecialFields {
6048        &self.special_fields
6049    }
6050
6051    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
6052        &mut self.special_fields
6053    }
6054
6055    fn new() -> AuthenticateDevice {
6056        AuthenticateDevice::new()
6057    }
6058
6059    fn clear(&mut self) {
6060        self.challenge = ::std::option::Option::None;
6061        self.special_fields.clear();
6062    }
6063
6064    fn default_instance() -> &'static AuthenticateDevice {
6065        static instance: AuthenticateDevice = AuthenticateDevice {
6066            challenge: ::std::option::Option::None,
6067            special_fields: ::protobuf::SpecialFields::new(),
6068        };
6069        &instance
6070    }
6071}
6072
6073impl ::protobuf::MessageFull for AuthenticateDevice {
6074    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
6075        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
6076        descriptor.get(|| file_descriptor().message_by_package_relative_name("AuthenticateDevice").unwrap()).clone()
6077    }
6078}
6079
6080impl ::std::fmt::Display for AuthenticateDevice {
6081    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6082        ::protobuf::text_format::fmt(self, f)
6083    }
6084}
6085
6086impl ::protobuf::reflect::ProtobufValue for AuthenticateDevice {
6087    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
6088}
6089
6090// @@protoc_insertion_point(message:hw.trezor.messages.management.AuthenticityProof)
6091#[derive(PartialEq,Clone,Default,Debug)]
6092pub struct AuthenticityProof {
6093    // message fields
6094    // @@protoc_insertion_point(field:hw.trezor.messages.management.AuthenticityProof.certificates)
6095    pub certificates: ::std::vec::Vec<::std::vec::Vec<u8>>,
6096    // @@protoc_insertion_point(field:hw.trezor.messages.management.AuthenticityProof.signature)
6097    pub signature: ::std::option::Option<::std::vec::Vec<u8>>,
6098    // special fields
6099    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.AuthenticityProof.special_fields)
6100    pub special_fields: ::protobuf::SpecialFields,
6101}
6102
6103impl<'a> ::std::default::Default for &'a AuthenticityProof {
6104    fn default() -> &'a AuthenticityProof {
6105        <AuthenticityProof as ::protobuf::Message>::default_instance()
6106    }
6107}
6108
6109impl AuthenticityProof {
6110    pub fn new() -> AuthenticityProof {
6111        ::std::default::Default::default()
6112    }
6113
6114    // required bytes signature = 2;
6115
6116    pub fn signature(&self) -> &[u8] {
6117        match self.signature.as_ref() {
6118            Some(v) => v,
6119            None => &[],
6120        }
6121    }
6122
6123    pub fn clear_signature(&mut self) {
6124        self.signature = ::std::option::Option::None;
6125    }
6126
6127    pub fn has_signature(&self) -> bool {
6128        self.signature.is_some()
6129    }
6130
6131    // Param is passed by value, moved
6132    pub fn set_signature(&mut self, v: ::std::vec::Vec<u8>) {
6133        self.signature = ::std::option::Option::Some(v);
6134    }
6135
6136    // Mutable pointer to the field.
6137    // If field is not initialized, it is initialized with default value first.
6138    pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec<u8> {
6139        if self.signature.is_none() {
6140            self.signature = ::std::option::Option::Some(::std::vec::Vec::new());
6141        }
6142        self.signature.as_mut().unwrap()
6143    }
6144
6145    // Take field
6146    pub fn take_signature(&mut self) -> ::std::vec::Vec<u8> {
6147        self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new())
6148    }
6149
6150    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
6151        let mut fields = ::std::vec::Vec::with_capacity(2);
6152        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6153        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6154            "certificates",
6155            |m: &AuthenticityProof| { &m.certificates },
6156            |m: &mut AuthenticityProof| { &mut m.certificates },
6157        ));
6158        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6159            "signature",
6160            |m: &AuthenticityProof| { &m.signature },
6161            |m: &mut AuthenticityProof| { &mut m.signature },
6162        ));
6163        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<AuthenticityProof>(
6164            "AuthenticityProof",
6165            fields,
6166            oneofs,
6167        )
6168    }
6169}
6170
6171impl ::protobuf::Message for AuthenticityProof {
6172    const NAME: &'static str = "AuthenticityProof";
6173
6174    fn is_initialized(&self) -> bool {
6175        if self.signature.is_none() {
6176            return false;
6177        }
6178        true
6179    }
6180
6181    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
6182        while let Some(tag) = is.read_raw_tag_or_eof()? {
6183            match tag {
6184                10 => {
6185                    self.certificates.push(is.read_bytes()?);
6186                },
6187                18 => {
6188                    self.signature = ::std::option::Option::Some(is.read_bytes()?);
6189                },
6190                tag => {
6191                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6192                },
6193            };
6194        }
6195        ::std::result::Result::Ok(())
6196    }
6197
6198    // Compute sizes of nested messages
6199    #[allow(unused_variables)]
6200    fn compute_size(&self) -> u64 {
6201        let mut my_size = 0;
6202        for value in &self.certificates {
6203            my_size += ::protobuf::rt::bytes_size(1, &value);
6204        };
6205        if let Some(v) = self.signature.as_ref() {
6206            my_size += ::protobuf::rt::bytes_size(2, &v);
6207        }
6208        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6209        self.special_fields.cached_size().set(my_size as u32);
6210        my_size
6211    }
6212
6213    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
6214        for v in &self.certificates {
6215            os.write_bytes(1, &v)?;
6216        };
6217        if let Some(v) = self.signature.as_ref() {
6218            os.write_bytes(2, v)?;
6219        }
6220        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6221        ::std::result::Result::Ok(())
6222    }
6223
6224    fn special_fields(&self) -> &::protobuf::SpecialFields {
6225        &self.special_fields
6226    }
6227
6228    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
6229        &mut self.special_fields
6230    }
6231
6232    fn new() -> AuthenticityProof {
6233        AuthenticityProof::new()
6234    }
6235
6236    fn clear(&mut self) {
6237        self.certificates.clear();
6238        self.signature = ::std::option::Option::None;
6239        self.special_fields.clear();
6240    }
6241
6242    fn default_instance() -> &'static AuthenticityProof {
6243        static instance: AuthenticityProof = AuthenticityProof {
6244            certificates: ::std::vec::Vec::new(),
6245            signature: ::std::option::Option::None,
6246            special_fields: ::protobuf::SpecialFields::new(),
6247        };
6248        &instance
6249    }
6250}
6251
6252impl ::protobuf::MessageFull for AuthenticityProof {
6253    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
6254        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
6255        descriptor.get(|| file_descriptor().message_by_package_relative_name("AuthenticityProof").unwrap()).clone()
6256    }
6257}
6258
6259impl ::std::fmt::Display for AuthenticityProof {
6260    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6261        ::protobuf::text_format::fmt(self, f)
6262    }
6263}
6264
6265impl ::protobuf::reflect::ProtobufValue for AuthenticityProof {
6266    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
6267}
6268
6269// @@protoc_insertion_point(message:hw.trezor.messages.management.WipeDevice)
6270#[derive(PartialEq,Clone,Default,Debug)]
6271pub struct WipeDevice {
6272    // special fields
6273    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.WipeDevice.special_fields)
6274    pub special_fields: ::protobuf::SpecialFields,
6275}
6276
6277impl<'a> ::std::default::Default for &'a WipeDevice {
6278    fn default() -> &'a WipeDevice {
6279        <WipeDevice as ::protobuf::Message>::default_instance()
6280    }
6281}
6282
6283impl WipeDevice {
6284    pub fn new() -> WipeDevice {
6285        ::std::default::Default::default()
6286    }
6287
6288    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
6289        let mut fields = ::std::vec::Vec::with_capacity(0);
6290        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6291        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<WipeDevice>(
6292            "WipeDevice",
6293            fields,
6294            oneofs,
6295        )
6296    }
6297}
6298
6299impl ::protobuf::Message for WipeDevice {
6300    const NAME: &'static str = "WipeDevice";
6301
6302    fn is_initialized(&self) -> bool {
6303        true
6304    }
6305
6306    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
6307        while let Some(tag) = is.read_raw_tag_or_eof()? {
6308            match tag {
6309                tag => {
6310                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6311                },
6312            };
6313        }
6314        ::std::result::Result::Ok(())
6315    }
6316
6317    // Compute sizes of nested messages
6318    #[allow(unused_variables)]
6319    fn compute_size(&self) -> u64 {
6320        let mut my_size = 0;
6321        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6322        self.special_fields.cached_size().set(my_size as u32);
6323        my_size
6324    }
6325
6326    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
6327        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6328        ::std::result::Result::Ok(())
6329    }
6330
6331    fn special_fields(&self) -> &::protobuf::SpecialFields {
6332        &self.special_fields
6333    }
6334
6335    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
6336        &mut self.special_fields
6337    }
6338
6339    fn new() -> WipeDevice {
6340        WipeDevice::new()
6341    }
6342
6343    fn clear(&mut self) {
6344        self.special_fields.clear();
6345    }
6346
6347    fn default_instance() -> &'static WipeDevice {
6348        static instance: WipeDevice = WipeDevice {
6349            special_fields: ::protobuf::SpecialFields::new(),
6350        };
6351        &instance
6352    }
6353}
6354
6355impl ::protobuf::MessageFull for WipeDevice {
6356    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
6357        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
6358        descriptor.get(|| file_descriptor().message_by_package_relative_name("WipeDevice").unwrap()).clone()
6359    }
6360}
6361
6362impl ::std::fmt::Display for WipeDevice {
6363    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6364        ::protobuf::text_format::fmt(self, f)
6365    }
6366}
6367
6368impl ::protobuf::reflect::ProtobufValue for WipeDevice {
6369    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
6370}
6371
6372// @@protoc_insertion_point(message:hw.trezor.messages.management.LoadDevice)
6373#[derive(PartialEq,Clone,Default,Debug)]
6374pub struct LoadDevice {
6375    // message fields
6376    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.mnemonics)
6377    pub mnemonics: ::std::vec::Vec<::std::string::String>,
6378    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.pin)
6379    pub pin: ::std::option::Option<::std::string::String>,
6380    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.passphrase_protection)
6381    pub passphrase_protection: ::std::option::Option<bool>,
6382    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.language)
6383    pub language: ::std::option::Option<::std::string::String>,
6384    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.label)
6385    pub label: ::std::option::Option<::std::string::String>,
6386    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.skip_checksum)
6387    pub skip_checksum: ::std::option::Option<bool>,
6388    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.u2f_counter)
6389    pub u2f_counter: ::std::option::Option<u32>,
6390    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.needs_backup)
6391    pub needs_backup: ::std::option::Option<bool>,
6392    // @@protoc_insertion_point(field:hw.trezor.messages.management.LoadDevice.no_backup)
6393    pub no_backup: ::std::option::Option<bool>,
6394    // special fields
6395    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.LoadDevice.special_fields)
6396    pub special_fields: ::protobuf::SpecialFields,
6397}
6398
6399impl<'a> ::std::default::Default for &'a LoadDevice {
6400    fn default() -> &'a LoadDevice {
6401        <LoadDevice as ::protobuf::Message>::default_instance()
6402    }
6403}
6404
6405impl LoadDevice {
6406    pub fn new() -> LoadDevice {
6407        ::std::default::Default::default()
6408    }
6409
6410    // optional string pin = 3;
6411
6412    pub fn pin(&self) -> &str {
6413        match self.pin.as_ref() {
6414            Some(v) => v,
6415            None => "",
6416        }
6417    }
6418
6419    pub fn clear_pin(&mut self) {
6420        self.pin = ::std::option::Option::None;
6421    }
6422
6423    pub fn has_pin(&self) -> bool {
6424        self.pin.is_some()
6425    }
6426
6427    // Param is passed by value, moved
6428    pub fn set_pin(&mut self, v: ::std::string::String) {
6429        self.pin = ::std::option::Option::Some(v);
6430    }
6431
6432    // Mutable pointer to the field.
6433    // If field is not initialized, it is initialized with default value first.
6434    pub fn mut_pin(&mut self) -> &mut ::std::string::String {
6435        if self.pin.is_none() {
6436            self.pin = ::std::option::Option::Some(::std::string::String::new());
6437        }
6438        self.pin.as_mut().unwrap()
6439    }
6440
6441    // Take field
6442    pub fn take_pin(&mut self) -> ::std::string::String {
6443        self.pin.take().unwrap_or_else(|| ::std::string::String::new())
6444    }
6445
6446    // optional bool passphrase_protection = 4;
6447
6448    pub fn passphrase_protection(&self) -> bool {
6449        self.passphrase_protection.unwrap_or(false)
6450    }
6451
6452    pub fn clear_passphrase_protection(&mut self) {
6453        self.passphrase_protection = ::std::option::Option::None;
6454    }
6455
6456    pub fn has_passphrase_protection(&self) -> bool {
6457        self.passphrase_protection.is_some()
6458    }
6459
6460    // Param is passed by value, moved
6461    pub fn set_passphrase_protection(&mut self, v: bool) {
6462        self.passphrase_protection = ::std::option::Option::Some(v);
6463    }
6464
6465    // optional string language = 5;
6466
6467    pub fn language(&self) -> &str {
6468        match self.language.as_ref() {
6469            Some(v) => v,
6470            None => "",
6471        }
6472    }
6473
6474    pub fn clear_language(&mut self) {
6475        self.language = ::std::option::Option::None;
6476    }
6477
6478    pub fn has_language(&self) -> bool {
6479        self.language.is_some()
6480    }
6481
6482    // Param is passed by value, moved
6483    pub fn set_language(&mut self, v: ::std::string::String) {
6484        self.language = ::std::option::Option::Some(v);
6485    }
6486
6487    // Mutable pointer to the field.
6488    // If field is not initialized, it is initialized with default value first.
6489    pub fn mut_language(&mut self) -> &mut ::std::string::String {
6490        if self.language.is_none() {
6491            self.language = ::std::option::Option::Some(::std::string::String::new());
6492        }
6493        self.language.as_mut().unwrap()
6494    }
6495
6496    // Take field
6497    pub fn take_language(&mut self) -> ::std::string::String {
6498        self.language.take().unwrap_or_else(|| ::std::string::String::new())
6499    }
6500
6501    // optional string label = 6;
6502
6503    pub fn label(&self) -> &str {
6504        match self.label.as_ref() {
6505            Some(v) => v,
6506            None => "",
6507        }
6508    }
6509
6510    pub fn clear_label(&mut self) {
6511        self.label = ::std::option::Option::None;
6512    }
6513
6514    pub fn has_label(&self) -> bool {
6515        self.label.is_some()
6516    }
6517
6518    // Param is passed by value, moved
6519    pub fn set_label(&mut self, v: ::std::string::String) {
6520        self.label = ::std::option::Option::Some(v);
6521    }
6522
6523    // Mutable pointer to the field.
6524    // If field is not initialized, it is initialized with default value first.
6525    pub fn mut_label(&mut self) -> &mut ::std::string::String {
6526        if self.label.is_none() {
6527            self.label = ::std::option::Option::Some(::std::string::String::new());
6528        }
6529        self.label.as_mut().unwrap()
6530    }
6531
6532    // Take field
6533    pub fn take_label(&mut self) -> ::std::string::String {
6534        self.label.take().unwrap_or_else(|| ::std::string::String::new())
6535    }
6536
6537    // optional bool skip_checksum = 7;
6538
6539    pub fn skip_checksum(&self) -> bool {
6540        self.skip_checksum.unwrap_or(false)
6541    }
6542
6543    pub fn clear_skip_checksum(&mut self) {
6544        self.skip_checksum = ::std::option::Option::None;
6545    }
6546
6547    pub fn has_skip_checksum(&self) -> bool {
6548        self.skip_checksum.is_some()
6549    }
6550
6551    // Param is passed by value, moved
6552    pub fn set_skip_checksum(&mut self, v: bool) {
6553        self.skip_checksum = ::std::option::Option::Some(v);
6554    }
6555
6556    // optional uint32 u2f_counter = 8;
6557
6558    pub fn u2f_counter(&self) -> u32 {
6559        self.u2f_counter.unwrap_or(0)
6560    }
6561
6562    pub fn clear_u2f_counter(&mut self) {
6563        self.u2f_counter = ::std::option::Option::None;
6564    }
6565
6566    pub fn has_u2f_counter(&self) -> bool {
6567        self.u2f_counter.is_some()
6568    }
6569
6570    // Param is passed by value, moved
6571    pub fn set_u2f_counter(&mut self, v: u32) {
6572        self.u2f_counter = ::std::option::Option::Some(v);
6573    }
6574
6575    // optional bool needs_backup = 9;
6576
6577    pub fn needs_backup(&self) -> bool {
6578        self.needs_backup.unwrap_or(false)
6579    }
6580
6581    pub fn clear_needs_backup(&mut self) {
6582        self.needs_backup = ::std::option::Option::None;
6583    }
6584
6585    pub fn has_needs_backup(&self) -> bool {
6586        self.needs_backup.is_some()
6587    }
6588
6589    // Param is passed by value, moved
6590    pub fn set_needs_backup(&mut self, v: bool) {
6591        self.needs_backup = ::std::option::Option::Some(v);
6592    }
6593
6594    // optional bool no_backup = 10;
6595
6596    pub fn no_backup(&self) -> bool {
6597        self.no_backup.unwrap_or(false)
6598    }
6599
6600    pub fn clear_no_backup(&mut self) {
6601        self.no_backup = ::std::option::Option::None;
6602    }
6603
6604    pub fn has_no_backup(&self) -> bool {
6605        self.no_backup.is_some()
6606    }
6607
6608    // Param is passed by value, moved
6609    pub fn set_no_backup(&mut self, v: bool) {
6610        self.no_backup = ::std::option::Option::Some(v);
6611    }
6612
6613    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
6614        let mut fields = ::std::vec::Vec::with_capacity(9);
6615        let mut oneofs = ::std::vec::Vec::with_capacity(0);
6616        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
6617            "mnemonics",
6618            |m: &LoadDevice| { &m.mnemonics },
6619            |m: &mut LoadDevice| { &mut m.mnemonics },
6620        ));
6621        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6622            "pin",
6623            |m: &LoadDevice| { &m.pin },
6624            |m: &mut LoadDevice| { &mut m.pin },
6625        ));
6626        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6627            "passphrase_protection",
6628            |m: &LoadDevice| { &m.passphrase_protection },
6629            |m: &mut LoadDevice| { &mut m.passphrase_protection },
6630        ));
6631        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6632            "language",
6633            |m: &LoadDevice| { &m.language },
6634            |m: &mut LoadDevice| { &mut m.language },
6635        ));
6636        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6637            "label",
6638            |m: &LoadDevice| { &m.label },
6639            |m: &mut LoadDevice| { &mut m.label },
6640        ));
6641        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6642            "skip_checksum",
6643            |m: &LoadDevice| { &m.skip_checksum },
6644            |m: &mut LoadDevice| { &mut m.skip_checksum },
6645        ));
6646        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6647            "u2f_counter",
6648            |m: &LoadDevice| { &m.u2f_counter },
6649            |m: &mut LoadDevice| { &mut m.u2f_counter },
6650        ));
6651        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6652            "needs_backup",
6653            |m: &LoadDevice| { &m.needs_backup },
6654            |m: &mut LoadDevice| { &mut m.needs_backup },
6655        ));
6656        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
6657            "no_backup",
6658            |m: &LoadDevice| { &m.no_backup },
6659            |m: &mut LoadDevice| { &mut m.no_backup },
6660        ));
6661        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<LoadDevice>(
6662            "LoadDevice",
6663            fields,
6664            oneofs,
6665        )
6666    }
6667}
6668
6669impl ::protobuf::Message for LoadDevice {
6670    const NAME: &'static str = "LoadDevice";
6671
6672    fn is_initialized(&self) -> bool {
6673        true
6674    }
6675
6676    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
6677        while let Some(tag) = is.read_raw_tag_or_eof()? {
6678            match tag {
6679                10 => {
6680                    self.mnemonics.push(is.read_string()?);
6681                },
6682                26 => {
6683                    self.pin = ::std::option::Option::Some(is.read_string()?);
6684                },
6685                32 => {
6686                    self.passphrase_protection = ::std::option::Option::Some(is.read_bool()?);
6687                },
6688                42 => {
6689                    self.language = ::std::option::Option::Some(is.read_string()?);
6690                },
6691                50 => {
6692                    self.label = ::std::option::Option::Some(is.read_string()?);
6693                },
6694                56 => {
6695                    self.skip_checksum = ::std::option::Option::Some(is.read_bool()?);
6696                },
6697                64 => {
6698                    self.u2f_counter = ::std::option::Option::Some(is.read_uint32()?);
6699                },
6700                72 => {
6701                    self.needs_backup = ::std::option::Option::Some(is.read_bool()?);
6702                },
6703                80 => {
6704                    self.no_backup = ::std::option::Option::Some(is.read_bool()?);
6705                },
6706                tag => {
6707                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
6708                },
6709            };
6710        }
6711        ::std::result::Result::Ok(())
6712    }
6713
6714    // Compute sizes of nested messages
6715    #[allow(unused_variables)]
6716    fn compute_size(&self) -> u64 {
6717        let mut my_size = 0;
6718        for value in &self.mnemonics {
6719            my_size += ::protobuf::rt::string_size(1, &value);
6720        };
6721        if let Some(v) = self.pin.as_ref() {
6722            my_size += ::protobuf::rt::string_size(3, &v);
6723        }
6724        if let Some(v) = self.passphrase_protection {
6725            my_size += 1 + 1;
6726        }
6727        if let Some(v) = self.language.as_ref() {
6728            my_size += ::protobuf::rt::string_size(5, &v);
6729        }
6730        if let Some(v) = self.label.as_ref() {
6731            my_size += ::protobuf::rt::string_size(6, &v);
6732        }
6733        if let Some(v) = self.skip_checksum {
6734            my_size += 1 + 1;
6735        }
6736        if let Some(v) = self.u2f_counter {
6737            my_size += ::protobuf::rt::uint32_size(8, v);
6738        }
6739        if let Some(v) = self.needs_backup {
6740            my_size += 1 + 1;
6741        }
6742        if let Some(v) = self.no_backup {
6743            my_size += 1 + 1;
6744        }
6745        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
6746        self.special_fields.cached_size().set(my_size as u32);
6747        my_size
6748    }
6749
6750    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
6751        for v in &self.mnemonics {
6752            os.write_string(1, &v)?;
6753        };
6754        if let Some(v) = self.pin.as_ref() {
6755            os.write_string(3, v)?;
6756        }
6757        if let Some(v) = self.passphrase_protection {
6758            os.write_bool(4, v)?;
6759        }
6760        if let Some(v) = self.language.as_ref() {
6761            os.write_string(5, v)?;
6762        }
6763        if let Some(v) = self.label.as_ref() {
6764            os.write_string(6, v)?;
6765        }
6766        if let Some(v) = self.skip_checksum {
6767            os.write_bool(7, v)?;
6768        }
6769        if let Some(v) = self.u2f_counter {
6770            os.write_uint32(8, v)?;
6771        }
6772        if let Some(v) = self.needs_backup {
6773            os.write_bool(9, v)?;
6774        }
6775        if let Some(v) = self.no_backup {
6776            os.write_bool(10, v)?;
6777        }
6778        os.write_unknown_fields(self.special_fields.unknown_fields())?;
6779        ::std::result::Result::Ok(())
6780    }
6781
6782    fn special_fields(&self) -> &::protobuf::SpecialFields {
6783        &self.special_fields
6784    }
6785
6786    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
6787        &mut self.special_fields
6788    }
6789
6790    fn new() -> LoadDevice {
6791        LoadDevice::new()
6792    }
6793
6794    fn clear(&mut self) {
6795        self.mnemonics.clear();
6796        self.pin = ::std::option::Option::None;
6797        self.passphrase_protection = ::std::option::Option::None;
6798        self.language = ::std::option::Option::None;
6799        self.label = ::std::option::Option::None;
6800        self.skip_checksum = ::std::option::Option::None;
6801        self.u2f_counter = ::std::option::Option::None;
6802        self.needs_backup = ::std::option::Option::None;
6803        self.no_backup = ::std::option::Option::None;
6804        self.special_fields.clear();
6805    }
6806
6807    fn default_instance() -> &'static LoadDevice {
6808        static instance: LoadDevice = LoadDevice {
6809            mnemonics: ::std::vec::Vec::new(),
6810            pin: ::std::option::Option::None,
6811            passphrase_protection: ::std::option::Option::None,
6812            language: ::std::option::Option::None,
6813            label: ::std::option::Option::None,
6814            skip_checksum: ::std::option::Option::None,
6815            u2f_counter: ::std::option::Option::None,
6816            needs_backup: ::std::option::Option::None,
6817            no_backup: ::std::option::Option::None,
6818            special_fields: ::protobuf::SpecialFields::new(),
6819        };
6820        &instance
6821    }
6822}
6823
6824impl ::protobuf::MessageFull for LoadDevice {
6825    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
6826        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
6827        descriptor.get(|| file_descriptor().message_by_package_relative_name("LoadDevice").unwrap()).clone()
6828    }
6829}
6830
6831impl ::std::fmt::Display for LoadDevice {
6832    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
6833        ::protobuf::text_format::fmt(self, f)
6834    }
6835}
6836
6837impl ::protobuf::reflect::ProtobufValue for LoadDevice {
6838    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
6839}
6840
6841// @@protoc_insertion_point(message:hw.trezor.messages.management.ResetDevice)
6842#[derive(PartialEq,Clone,Default,Debug)]
6843pub struct ResetDevice {
6844    // message fields
6845    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.display_random)
6846    pub display_random: ::std::option::Option<bool>,
6847    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.strength)
6848    pub strength: ::std::option::Option<u32>,
6849    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.passphrase_protection)
6850    pub passphrase_protection: ::std::option::Option<bool>,
6851    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.pin_protection)
6852    pub pin_protection: ::std::option::Option<bool>,
6853    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.language)
6854    pub language: ::std::option::Option<::std::string::String>,
6855    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.label)
6856    pub label: ::std::option::Option<::std::string::String>,
6857    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.u2f_counter)
6858    pub u2f_counter: ::std::option::Option<u32>,
6859    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.skip_backup)
6860    pub skip_backup: ::std::option::Option<bool>,
6861    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.no_backup)
6862    pub no_backup: ::std::option::Option<bool>,
6863    // @@protoc_insertion_point(field:hw.trezor.messages.management.ResetDevice.backup_type)
6864    pub backup_type: ::std::option::Option<::protobuf::EnumOrUnknown<BackupType>>,
6865    // special fields
6866    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ResetDevice.special_fields)
6867    pub special_fields: ::protobuf::SpecialFields,
6868}
6869
6870impl<'a> ::std::default::Default for &'a ResetDevice {
6871    fn default() -> &'a ResetDevice {
6872        <ResetDevice as ::protobuf::Message>::default_instance()
6873    }
6874}
6875
6876impl ResetDevice {
6877    pub fn new() -> ResetDevice {
6878        ::std::default::Default::default()
6879    }
6880
6881    // optional bool display_random = 1;
6882
6883    pub fn display_random(&self) -> bool {
6884        self.display_random.unwrap_or(false)
6885    }
6886
6887    pub fn clear_display_random(&mut self) {
6888        self.display_random = ::std::option::Option::None;
6889    }
6890
6891    pub fn has_display_random(&self) -> bool {
6892        self.display_random.is_some()
6893    }
6894
6895    // Param is passed by value, moved
6896    pub fn set_display_random(&mut self, v: bool) {
6897        self.display_random = ::std::option::Option::Some(v);
6898    }
6899
6900    // optional uint32 strength = 2;
6901
6902    pub fn strength(&self) -> u32 {
6903        self.strength.unwrap_or(256u32)
6904    }
6905
6906    pub fn clear_strength(&mut self) {
6907        self.strength = ::std::option::Option::None;
6908    }
6909
6910    pub fn has_strength(&self) -> bool {
6911        self.strength.is_some()
6912    }
6913
6914    // Param is passed by value, moved
6915    pub fn set_strength(&mut self, v: u32) {
6916        self.strength = ::std::option::Option::Some(v);
6917    }
6918
6919    // optional bool passphrase_protection = 3;
6920
6921    pub fn passphrase_protection(&self) -> bool {
6922        self.passphrase_protection.unwrap_or(false)
6923    }
6924
6925    pub fn clear_passphrase_protection(&mut self) {
6926        self.passphrase_protection = ::std::option::Option::None;
6927    }
6928
6929    pub fn has_passphrase_protection(&self) -> bool {
6930        self.passphrase_protection.is_some()
6931    }
6932
6933    // Param is passed by value, moved
6934    pub fn set_passphrase_protection(&mut self, v: bool) {
6935        self.passphrase_protection = ::std::option::Option::Some(v);
6936    }
6937
6938    // optional bool pin_protection = 4;
6939
6940    pub fn pin_protection(&self) -> bool {
6941        self.pin_protection.unwrap_or(false)
6942    }
6943
6944    pub fn clear_pin_protection(&mut self) {
6945        self.pin_protection = ::std::option::Option::None;
6946    }
6947
6948    pub fn has_pin_protection(&self) -> bool {
6949        self.pin_protection.is_some()
6950    }
6951
6952    // Param is passed by value, moved
6953    pub fn set_pin_protection(&mut self, v: bool) {
6954        self.pin_protection = ::std::option::Option::Some(v);
6955    }
6956
6957    // optional string language = 5;
6958
6959    pub fn language(&self) -> &str {
6960        match self.language.as_ref() {
6961            Some(v) => v,
6962            None => "",
6963        }
6964    }
6965
6966    pub fn clear_language(&mut self) {
6967        self.language = ::std::option::Option::None;
6968    }
6969
6970    pub fn has_language(&self) -> bool {
6971        self.language.is_some()
6972    }
6973
6974    // Param is passed by value, moved
6975    pub fn set_language(&mut self, v: ::std::string::String) {
6976        self.language = ::std::option::Option::Some(v);
6977    }
6978
6979    // Mutable pointer to the field.
6980    // If field is not initialized, it is initialized with default value first.
6981    pub fn mut_language(&mut self) -> &mut ::std::string::String {
6982        if self.language.is_none() {
6983            self.language = ::std::option::Option::Some(::std::string::String::new());
6984        }
6985        self.language.as_mut().unwrap()
6986    }
6987
6988    // Take field
6989    pub fn take_language(&mut self) -> ::std::string::String {
6990        self.language.take().unwrap_or_else(|| ::std::string::String::new())
6991    }
6992
6993    // optional string label = 6;
6994
6995    pub fn label(&self) -> &str {
6996        match self.label.as_ref() {
6997            Some(v) => v,
6998            None => "",
6999        }
7000    }
7001
7002    pub fn clear_label(&mut self) {
7003        self.label = ::std::option::Option::None;
7004    }
7005
7006    pub fn has_label(&self) -> bool {
7007        self.label.is_some()
7008    }
7009
7010    // Param is passed by value, moved
7011    pub fn set_label(&mut self, v: ::std::string::String) {
7012        self.label = ::std::option::Option::Some(v);
7013    }
7014
7015    // Mutable pointer to the field.
7016    // If field is not initialized, it is initialized with default value first.
7017    pub fn mut_label(&mut self) -> &mut ::std::string::String {
7018        if self.label.is_none() {
7019            self.label = ::std::option::Option::Some(::std::string::String::new());
7020        }
7021        self.label.as_mut().unwrap()
7022    }
7023
7024    // Take field
7025    pub fn take_label(&mut self) -> ::std::string::String {
7026        self.label.take().unwrap_or_else(|| ::std::string::String::new())
7027    }
7028
7029    // optional uint32 u2f_counter = 7;
7030
7031    pub fn u2f_counter(&self) -> u32 {
7032        self.u2f_counter.unwrap_or(0)
7033    }
7034
7035    pub fn clear_u2f_counter(&mut self) {
7036        self.u2f_counter = ::std::option::Option::None;
7037    }
7038
7039    pub fn has_u2f_counter(&self) -> bool {
7040        self.u2f_counter.is_some()
7041    }
7042
7043    // Param is passed by value, moved
7044    pub fn set_u2f_counter(&mut self, v: u32) {
7045        self.u2f_counter = ::std::option::Option::Some(v);
7046    }
7047
7048    // optional bool skip_backup = 8;
7049
7050    pub fn skip_backup(&self) -> bool {
7051        self.skip_backup.unwrap_or(false)
7052    }
7053
7054    pub fn clear_skip_backup(&mut self) {
7055        self.skip_backup = ::std::option::Option::None;
7056    }
7057
7058    pub fn has_skip_backup(&self) -> bool {
7059        self.skip_backup.is_some()
7060    }
7061
7062    // Param is passed by value, moved
7063    pub fn set_skip_backup(&mut self, v: bool) {
7064        self.skip_backup = ::std::option::Option::Some(v);
7065    }
7066
7067    // optional bool no_backup = 9;
7068
7069    pub fn no_backup(&self) -> bool {
7070        self.no_backup.unwrap_or(false)
7071    }
7072
7073    pub fn clear_no_backup(&mut self) {
7074        self.no_backup = ::std::option::Option::None;
7075    }
7076
7077    pub fn has_no_backup(&self) -> bool {
7078        self.no_backup.is_some()
7079    }
7080
7081    // Param is passed by value, moved
7082    pub fn set_no_backup(&mut self, v: bool) {
7083        self.no_backup = ::std::option::Option::Some(v);
7084    }
7085
7086    // optional .hw.trezor.messages.management.BackupType backup_type = 10;
7087
7088    pub fn backup_type(&self) -> BackupType {
7089        match self.backup_type {
7090            Some(e) => e.enum_value_or(BackupType::Bip39),
7091            None => BackupType::Bip39,
7092        }
7093    }
7094
7095    pub fn clear_backup_type(&mut self) {
7096        self.backup_type = ::std::option::Option::None;
7097    }
7098
7099    pub fn has_backup_type(&self) -> bool {
7100        self.backup_type.is_some()
7101    }
7102
7103    // Param is passed by value, moved
7104    pub fn set_backup_type(&mut self, v: BackupType) {
7105        self.backup_type = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
7106    }
7107
7108    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
7109        let mut fields = ::std::vec::Vec::with_capacity(10);
7110        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7111        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7112            "display_random",
7113            |m: &ResetDevice| { &m.display_random },
7114            |m: &mut ResetDevice| { &mut m.display_random },
7115        ));
7116        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7117            "strength",
7118            |m: &ResetDevice| { &m.strength },
7119            |m: &mut ResetDevice| { &mut m.strength },
7120        ));
7121        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7122            "passphrase_protection",
7123            |m: &ResetDevice| { &m.passphrase_protection },
7124            |m: &mut ResetDevice| { &mut m.passphrase_protection },
7125        ));
7126        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7127            "pin_protection",
7128            |m: &ResetDevice| { &m.pin_protection },
7129            |m: &mut ResetDevice| { &mut m.pin_protection },
7130        ));
7131        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7132            "language",
7133            |m: &ResetDevice| { &m.language },
7134            |m: &mut ResetDevice| { &mut m.language },
7135        ));
7136        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7137            "label",
7138            |m: &ResetDevice| { &m.label },
7139            |m: &mut ResetDevice| { &mut m.label },
7140        ));
7141        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7142            "u2f_counter",
7143            |m: &ResetDevice| { &m.u2f_counter },
7144            |m: &mut ResetDevice| { &mut m.u2f_counter },
7145        ));
7146        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7147            "skip_backup",
7148            |m: &ResetDevice| { &m.skip_backup },
7149            |m: &mut ResetDevice| { &mut m.skip_backup },
7150        ));
7151        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7152            "no_backup",
7153            |m: &ResetDevice| { &m.no_backup },
7154            |m: &mut ResetDevice| { &mut m.no_backup },
7155        ));
7156        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7157            "backup_type",
7158            |m: &ResetDevice| { &m.backup_type },
7159            |m: &mut ResetDevice| { &mut m.backup_type },
7160        ));
7161        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ResetDevice>(
7162            "ResetDevice",
7163            fields,
7164            oneofs,
7165        )
7166    }
7167}
7168
7169impl ::protobuf::Message for ResetDevice {
7170    const NAME: &'static str = "ResetDevice";
7171
7172    fn is_initialized(&self) -> bool {
7173        true
7174    }
7175
7176    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
7177        while let Some(tag) = is.read_raw_tag_or_eof()? {
7178            match tag {
7179                8 => {
7180                    self.display_random = ::std::option::Option::Some(is.read_bool()?);
7181                },
7182                16 => {
7183                    self.strength = ::std::option::Option::Some(is.read_uint32()?);
7184                },
7185                24 => {
7186                    self.passphrase_protection = ::std::option::Option::Some(is.read_bool()?);
7187                },
7188                32 => {
7189                    self.pin_protection = ::std::option::Option::Some(is.read_bool()?);
7190                },
7191                42 => {
7192                    self.language = ::std::option::Option::Some(is.read_string()?);
7193                },
7194                50 => {
7195                    self.label = ::std::option::Option::Some(is.read_string()?);
7196                },
7197                56 => {
7198                    self.u2f_counter = ::std::option::Option::Some(is.read_uint32()?);
7199                },
7200                64 => {
7201                    self.skip_backup = ::std::option::Option::Some(is.read_bool()?);
7202                },
7203                72 => {
7204                    self.no_backup = ::std::option::Option::Some(is.read_bool()?);
7205                },
7206                80 => {
7207                    self.backup_type = ::std::option::Option::Some(is.read_enum_or_unknown()?);
7208                },
7209                tag => {
7210                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7211                },
7212            };
7213        }
7214        ::std::result::Result::Ok(())
7215    }
7216
7217    // Compute sizes of nested messages
7218    #[allow(unused_variables)]
7219    fn compute_size(&self) -> u64 {
7220        let mut my_size = 0;
7221        if let Some(v) = self.display_random {
7222            my_size += 1 + 1;
7223        }
7224        if let Some(v) = self.strength {
7225            my_size += ::protobuf::rt::uint32_size(2, v);
7226        }
7227        if let Some(v) = self.passphrase_protection {
7228            my_size += 1 + 1;
7229        }
7230        if let Some(v) = self.pin_protection {
7231            my_size += 1 + 1;
7232        }
7233        if let Some(v) = self.language.as_ref() {
7234            my_size += ::protobuf::rt::string_size(5, &v);
7235        }
7236        if let Some(v) = self.label.as_ref() {
7237            my_size += ::protobuf::rt::string_size(6, &v);
7238        }
7239        if let Some(v) = self.u2f_counter {
7240            my_size += ::protobuf::rt::uint32_size(7, v);
7241        }
7242        if let Some(v) = self.skip_backup {
7243            my_size += 1 + 1;
7244        }
7245        if let Some(v) = self.no_backup {
7246            my_size += 1 + 1;
7247        }
7248        if let Some(v) = self.backup_type {
7249            my_size += ::protobuf::rt::int32_size(10, v.value());
7250        }
7251        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7252        self.special_fields.cached_size().set(my_size as u32);
7253        my_size
7254    }
7255
7256    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
7257        if let Some(v) = self.display_random {
7258            os.write_bool(1, v)?;
7259        }
7260        if let Some(v) = self.strength {
7261            os.write_uint32(2, v)?;
7262        }
7263        if let Some(v) = self.passphrase_protection {
7264            os.write_bool(3, v)?;
7265        }
7266        if let Some(v) = self.pin_protection {
7267            os.write_bool(4, v)?;
7268        }
7269        if let Some(v) = self.language.as_ref() {
7270            os.write_string(5, v)?;
7271        }
7272        if let Some(v) = self.label.as_ref() {
7273            os.write_string(6, v)?;
7274        }
7275        if let Some(v) = self.u2f_counter {
7276            os.write_uint32(7, v)?;
7277        }
7278        if let Some(v) = self.skip_backup {
7279            os.write_bool(8, v)?;
7280        }
7281        if let Some(v) = self.no_backup {
7282            os.write_bool(9, v)?;
7283        }
7284        if let Some(v) = self.backup_type {
7285            os.write_enum(10, ::protobuf::EnumOrUnknown::value(&v))?;
7286        }
7287        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7288        ::std::result::Result::Ok(())
7289    }
7290
7291    fn special_fields(&self) -> &::protobuf::SpecialFields {
7292        &self.special_fields
7293    }
7294
7295    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
7296        &mut self.special_fields
7297    }
7298
7299    fn new() -> ResetDevice {
7300        ResetDevice::new()
7301    }
7302
7303    fn clear(&mut self) {
7304        self.display_random = ::std::option::Option::None;
7305        self.strength = ::std::option::Option::None;
7306        self.passphrase_protection = ::std::option::Option::None;
7307        self.pin_protection = ::std::option::Option::None;
7308        self.language = ::std::option::Option::None;
7309        self.label = ::std::option::Option::None;
7310        self.u2f_counter = ::std::option::Option::None;
7311        self.skip_backup = ::std::option::Option::None;
7312        self.no_backup = ::std::option::Option::None;
7313        self.backup_type = ::std::option::Option::None;
7314        self.special_fields.clear();
7315    }
7316
7317    fn default_instance() -> &'static ResetDevice {
7318        static instance: ResetDevice = ResetDevice {
7319            display_random: ::std::option::Option::None,
7320            strength: ::std::option::Option::None,
7321            passphrase_protection: ::std::option::Option::None,
7322            pin_protection: ::std::option::Option::None,
7323            language: ::std::option::Option::None,
7324            label: ::std::option::Option::None,
7325            u2f_counter: ::std::option::Option::None,
7326            skip_backup: ::std::option::Option::None,
7327            no_backup: ::std::option::Option::None,
7328            backup_type: ::std::option::Option::None,
7329            special_fields: ::protobuf::SpecialFields::new(),
7330        };
7331        &instance
7332    }
7333}
7334
7335impl ::protobuf::MessageFull for ResetDevice {
7336    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
7337        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
7338        descriptor.get(|| file_descriptor().message_by_package_relative_name("ResetDevice").unwrap()).clone()
7339    }
7340}
7341
7342impl ::std::fmt::Display for ResetDevice {
7343    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7344        ::protobuf::text_format::fmt(self, f)
7345    }
7346}
7347
7348impl ::protobuf::reflect::ProtobufValue for ResetDevice {
7349    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
7350}
7351
7352// @@protoc_insertion_point(message:hw.trezor.messages.management.BackupDevice)
7353#[derive(PartialEq,Clone,Default,Debug)]
7354pub struct BackupDevice {
7355    // message fields
7356    // @@protoc_insertion_point(field:hw.trezor.messages.management.BackupDevice.group_threshold)
7357    pub group_threshold: ::std::option::Option<u32>,
7358    // @@protoc_insertion_point(field:hw.trezor.messages.management.BackupDevice.groups)
7359    pub groups: ::std::vec::Vec<backup_device::Slip39Group>,
7360    // special fields
7361    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.BackupDevice.special_fields)
7362    pub special_fields: ::protobuf::SpecialFields,
7363}
7364
7365impl<'a> ::std::default::Default for &'a BackupDevice {
7366    fn default() -> &'a BackupDevice {
7367        <BackupDevice as ::protobuf::Message>::default_instance()
7368    }
7369}
7370
7371impl BackupDevice {
7372    pub fn new() -> BackupDevice {
7373        ::std::default::Default::default()
7374    }
7375
7376    // optional uint32 group_threshold = 1;
7377
7378    pub fn group_threshold(&self) -> u32 {
7379        self.group_threshold.unwrap_or(0)
7380    }
7381
7382    pub fn clear_group_threshold(&mut self) {
7383        self.group_threshold = ::std::option::Option::None;
7384    }
7385
7386    pub fn has_group_threshold(&self) -> bool {
7387        self.group_threshold.is_some()
7388    }
7389
7390    // Param is passed by value, moved
7391    pub fn set_group_threshold(&mut self, v: u32) {
7392        self.group_threshold = ::std::option::Option::Some(v);
7393    }
7394
7395    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
7396        let mut fields = ::std::vec::Vec::with_capacity(2);
7397        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7398        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7399            "group_threshold",
7400            |m: &BackupDevice| { &m.group_threshold },
7401            |m: &mut BackupDevice| { &mut m.group_threshold },
7402        ));
7403        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
7404            "groups",
7405            |m: &BackupDevice| { &m.groups },
7406            |m: &mut BackupDevice| { &mut m.groups },
7407        ));
7408        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BackupDevice>(
7409            "BackupDevice",
7410            fields,
7411            oneofs,
7412        )
7413    }
7414}
7415
7416impl ::protobuf::Message for BackupDevice {
7417    const NAME: &'static str = "BackupDevice";
7418
7419    fn is_initialized(&self) -> bool {
7420        for v in &self.groups {
7421            if !v.is_initialized() {
7422                return false;
7423            }
7424        };
7425        true
7426    }
7427
7428    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
7429        while let Some(tag) = is.read_raw_tag_or_eof()? {
7430            match tag {
7431                8 => {
7432                    self.group_threshold = ::std::option::Option::Some(is.read_uint32()?);
7433                },
7434                18 => {
7435                    self.groups.push(is.read_message()?);
7436                },
7437                tag => {
7438                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7439                },
7440            };
7441        }
7442        ::std::result::Result::Ok(())
7443    }
7444
7445    // Compute sizes of nested messages
7446    #[allow(unused_variables)]
7447    fn compute_size(&self) -> u64 {
7448        let mut my_size = 0;
7449        if let Some(v) = self.group_threshold {
7450            my_size += ::protobuf::rt::uint32_size(1, v);
7451        }
7452        for value in &self.groups {
7453            let len = value.compute_size();
7454            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
7455        };
7456        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7457        self.special_fields.cached_size().set(my_size as u32);
7458        my_size
7459    }
7460
7461    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
7462        if let Some(v) = self.group_threshold {
7463            os.write_uint32(1, v)?;
7464        }
7465        for v in &self.groups {
7466            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
7467        };
7468        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7469        ::std::result::Result::Ok(())
7470    }
7471
7472    fn special_fields(&self) -> &::protobuf::SpecialFields {
7473        &self.special_fields
7474    }
7475
7476    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
7477        &mut self.special_fields
7478    }
7479
7480    fn new() -> BackupDevice {
7481        BackupDevice::new()
7482    }
7483
7484    fn clear(&mut self) {
7485        self.group_threshold = ::std::option::Option::None;
7486        self.groups.clear();
7487        self.special_fields.clear();
7488    }
7489
7490    fn default_instance() -> &'static BackupDevice {
7491        static instance: BackupDevice = BackupDevice {
7492            group_threshold: ::std::option::Option::None,
7493            groups: ::std::vec::Vec::new(),
7494            special_fields: ::protobuf::SpecialFields::new(),
7495        };
7496        &instance
7497    }
7498}
7499
7500impl ::protobuf::MessageFull for BackupDevice {
7501    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
7502        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
7503        descriptor.get(|| file_descriptor().message_by_package_relative_name("BackupDevice").unwrap()).clone()
7504    }
7505}
7506
7507impl ::std::fmt::Display for BackupDevice {
7508    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7509        ::protobuf::text_format::fmt(self, f)
7510    }
7511}
7512
7513impl ::protobuf::reflect::ProtobufValue for BackupDevice {
7514    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
7515}
7516
7517/// Nested message and enums of message `BackupDevice`
7518pub mod backup_device {
7519    // @@protoc_insertion_point(message:hw.trezor.messages.management.BackupDevice.Slip39Group)
7520    #[derive(PartialEq,Clone,Default,Debug)]
7521    pub struct Slip39Group {
7522        // message fields
7523        // @@protoc_insertion_point(field:hw.trezor.messages.management.BackupDevice.Slip39Group.member_threshold)
7524        pub member_threshold: ::std::option::Option<u32>,
7525        // @@protoc_insertion_point(field:hw.trezor.messages.management.BackupDevice.Slip39Group.member_count)
7526        pub member_count: ::std::option::Option<u32>,
7527        // special fields
7528        // @@protoc_insertion_point(special_field:hw.trezor.messages.management.BackupDevice.Slip39Group.special_fields)
7529        pub special_fields: ::protobuf::SpecialFields,
7530    }
7531
7532    impl<'a> ::std::default::Default for &'a Slip39Group {
7533        fn default() -> &'a Slip39Group {
7534            <Slip39Group as ::protobuf::Message>::default_instance()
7535        }
7536    }
7537
7538    impl Slip39Group {
7539        pub fn new() -> Slip39Group {
7540            ::std::default::Default::default()
7541        }
7542
7543        // required uint32 member_threshold = 1;
7544
7545        pub fn member_threshold(&self) -> u32 {
7546            self.member_threshold.unwrap_or(0)
7547        }
7548
7549        pub fn clear_member_threshold(&mut self) {
7550            self.member_threshold = ::std::option::Option::None;
7551        }
7552
7553        pub fn has_member_threshold(&self) -> bool {
7554            self.member_threshold.is_some()
7555        }
7556
7557        // Param is passed by value, moved
7558        pub fn set_member_threshold(&mut self, v: u32) {
7559            self.member_threshold = ::std::option::Option::Some(v);
7560        }
7561
7562        // required uint32 member_count = 2;
7563
7564        pub fn member_count(&self) -> u32 {
7565            self.member_count.unwrap_or(0)
7566        }
7567
7568        pub fn clear_member_count(&mut self) {
7569            self.member_count = ::std::option::Option::None;
7570        }
7571
7572        pub fn has_member_count(&self) -> bool {
7573            self.member_count.is_some()
7574        }
7575
7576        // Param is passed by value, moved
7577        pub fn set_member_count(&mut self, v: u32) {
7578            self.member_count = ::std::option::Option::Some(v);
7579        }
7580
7581        pub(in super) fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
7582            let mut fields = ::std::vec::Vec::with_capacity(2);
7583            let mut oneofs = ::std::vec::Vec::with_capacity(0);
7584            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7585                "member_threshold",
7586                |m: &Slip39Group| { &m.member_threshold },
7587                |m: &mut Slip39Group| { &mut m.member_threshold },
7588            ));
7589            fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7590                "member_count",
7591                |m: &Slip39Group| { &m.member_count },
7592                |m: &mut Slip39Group| { &mut m.member_count },
7593            ));
7594            ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Slip39Group>(
7595                "BackupDevice.Slip39Group",
7596                fields,
7597                oneofs,
7598            )
7599        }
7600    }
7601
7602    impl ::protobuf::Message for Slip39Group {
7603        const NAME: &'static str = "Slip39Group";
7604
7605        fn is_initialized(&self) -> bool {
7606            if self.member_threshold.is_none() {
7607                return false;
7608            }
7609            if self.member_count.is_none() {
7610                return false;
7611            }
7612            true
7613        }
7614
7615        fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
7616            while let Some(tag) = is.read_raw_tag_or_eof()? {
7617                match tag {
7618                    8 => {
7619                        self.member_threshold = ::std::option::Option::Some(is.read_uint32()?);
7620                    },
7621                    16 => {
7622                        self.member_count = ::std::option::Option::Some(is.read_uint32()?);
7623                    },
7624                    tag => {
7625                        ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7626                    },
7627                };
7628            }
7629            ::std::result::Result::Ok(())
7630        }
7631
7632        // Compute sizes of nested messages
7633        #[allow(unused_variables)]
7634        fn compute_size(&self) -> u64 {
7635            let mut my_size = 0;
7636            if let Some(v) = self.member_threshold {
7637                my_size += ::protobuf::rt::uint32_size(1, v);
7638            }
7639            if let Some(v) = self.member_count {
7640                my_size += ::protobuf::rt::uint32_size(2, v);
7641            }
7642            my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7643            self.special_fields.cached_size().set(my_size as u32);
7644            my_size
7645        }
7646
7647        fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
7648            if let Some(v) = self.member_threshold {
7649                os.write_uint32(1, v)?;
7650            }
7651            if let Some(v) = self.member_count {
7652                os.write_uint32(2, v)?;
7653            }
7654            os.write_unknown_fields(self.special_fields.unknown_fields())?;
7655            ::std::result::Result::Ok(())
7656        }
7657
7658        fn special_fields(&self) -> &::protobuf::SpecialFields {
7659            &self.special_fields
7660        }
7661
7662        fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
7663            &mut self.special_fields
7664        }
7665
7666        fn new() -> Slip39Group {
7667            Slip39Group::new()
7668        }
7669
7670        fn clear(&mut self) {
7671            self.member_threshold = ::std::option::Option::None;
7672            self.member_count = ::std::option::Option::None;
7673            self.special_fields.clear();
7674        }
7675
7676        fn default_instance() -> &'static Slip39Group {
7677            static instance: Slip39Group = Slip39Group {
7678                member_threshold: ::std::option::Option::None,
7679                member_count: ::std::option::Option::None,
7680                special_fields: ::protobuf::SpecialFields::new(),
7681            };
7682            &instance
7683        }
7684    }
7685
7686    impl ::protobuf::MessageFull for Slip39Group {
7687        fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
7688            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
7689            descriptor.get(|| super::file_descriptor().message_by_package_relative_name("BackupDevice.Slip39Group").unwrap()).clone()
7690        }
7691    }
7692
7693    impl ::std::fmt::Display for Slip39Group {
7694        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7695            ::protobuf::text_format::fmt(self, f)
7696        }
7697    }
7698
7699    impl ::protobuf::reflect::ProtobufValue for Slip39Group {
7700        type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
7701    }
7702}
7703
7704// @@protoc_insertion_point(message:hw.trezor.messages.management.EntropyRequest)
7705#[derive(PartialEq,Clone,Default,Debug)]
7706pub struct EntropyRequest {
7707    // special fields
7708    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EntropyRequest.special_fields)
7709    pub special_fields: ::protobuf::SpecialFields,
7710}
7711
7712impl<'a> ::std::default::Default for &'a EntropyRequest {
7713    fn default() -> &'a EntropyRequest {
7714        <EntropyRequest as ::protobuf::Message>::default_instance()
7715    }
7716}
7717
7718impl EntropyRequest {
7719    pub fn new() -> EntropyRequest {
7720        ::std::default::Default::default()
7721    }
7722
7723    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
7724        let mut fields = ::std::vec::Vec::with_capacity(0);
7725        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7726        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EntropyRequest>(
7727            "EntropyRequest",
7728            fields,
7729            oneofs,
7730        )
7731    }
7732}
7733
7734impl ::protobuf::Message for EntropyRequest {
7735    const NAME: &'static str = "EntropyRequest";
7736
7737    fn is_initialized(&self) -> bool {
7738        true
7739    }
7740
7741    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
7742        while let Some(tag) = is.read_raw_tag_or_eof()? {
7743            match tag {
7744                tag => {
7745                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7746                },
7747            };
7748        }
7749        ::std::result::Result::Ok(())
7750    }
7751
7752    // Compute sizes of nested messages
7753    #[allow(unused_variables)]
7754    fn compute_size(&self) -> u64 {
7755        let mut my_size = 0;
7756        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7757        self.special_fields.cached_size().set(my_size as u32);
7758        my_size
7759    }
7760
7761    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
7762        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7763        ::std::result::Result::Ok(())
7764    }
7765
7766    fn special_fields(&self) -> &::protobuf::SpecialFields {
7767        &self.special_fields
7768    }
7769
7770    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
7771        &mut self.special_fields
7772    }
7773
7774    fn new() -> EntropyRequest {
7775        EntropyRequest::new()
7776    }
7777
7778    fn clear(&mut self) {
7779        self.special_fields.clear();
7780    }
7781
7782    fn default_instance() -> &'static EntropyRequest {
7783        static instance: EntropyRequest = EntropyRequest {
7784            special_fields: ::protobuf::SpecialFields::new(),
7785        };
7786        &instance
7787    }
7788}
7789
7790impl ::protobuf::MessageFull for EntropyRequest {
7791    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
7792        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
7793        descriptor.get(|| file_descriptor().message_by_package_relative_name("EntropyRequest").unwrap()).clone()
7794    }
7795}
7796
7797impl ::std::fmt::Display for EntropyRequest {
7798    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7799        ::protobuf::text_format::fmt(self, f)
7800    }
7801}
7802
7803impl ::protobuf::reflect::ProtobufValue for EntropyRequest {
7804    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
7805}
7806
7807// @@protoc_insertion_point(message:hw.trezor.messages.management.EntropyAck)
7808#[derive(PartialEq,Clone,Default,Debug)]
7809pub struct EntropyAck {
7810    // message fields
7811    // @@protoc_insertion_point(field:hw.trezor.messages.management.EntropyAck.entropy)
7812    pub entropy: ::std::option::Option<::std::vec::Vec<u8>>,
7813    // special fields
7814    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.EntropyAck.special_fields)
7815    pub special_fields: ::protobuf::SpecialFields,
7816}
7817
7818impl<'a> ::std::default::Default for &'a EntropyAck {
7819    fn default() -> &'a EntropyAck {
7820        <EntropyAck as ::protobuf::Message>::default_instance()
7821    }
7822}
7823
7824impl EntropyAck {
7825    pub fn new() -> EntropyAck {
7826        ::std::default::Default::default()
7827    }
7828
7829    // required bytes entropy = 1;
7830
7831    pub fn entropy(&self) -> &[u8] {
7832        match self.entropy.as_ref() {
7833            Some(v) => v,
7834            None => &[],
7835        }
7836    }
7837
7838    pub fn clear_entropy(&mut self) {
7839        self.entropy = ::std::option::Option::None;
7840    }
7841
7842    pub fn has_entropy(&self) -> bool {
7843        self.entropy.is_some()
7844    }
7845
7846    // Param is passed by value, moved
7847    pub fn set_entropy(&mut self, v: ::std::vec::Vec<u8>) {
7848        self.entropy = ::std::option::Option::Some(v);
7849    }
7850
7851    // Mutable pointer to the field.
7852    // If field is not initialized, it is initialized with default value first.
7853    pub fn mut_entropy(&mut self) -> &mut ::std::vec::Vec<u8> {
7854        if self.entropy.is_none() {
7855            self.entropy = ::std::option::Option::Some(::std::vec::Vec::new());
7856        }
7857        self.entropy.as_mut().unwrap()
7858    }
7859
7860    // Take field
7861    pub fn take_entropy(&mut self) -> ::std::vec::Vec<u8> {
7862        self.entropy.take().unwrap_or_else(|| ::std::vec::Vec::new())
7863    }
7864
7865    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
7866        let mut fields = ::std::vec::Vec::with_capacity(1);
7867        let mut oneofs = ::std::vec::Vec::with_capacity(0);
7868        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
7869            "entropy",
7870            |m: &EntropyAck| { &m.entropy },
7871            |m: &mut EntropyAck| { &mut m.entropy },
7872        ));
7873        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<EntropyAck>(
7874            "EntropyAck",
7875            fields,
7876            oneofs,
7877        )
7878    }
7879}
7880
7881impl ::protobuf::Message for EntropyAck {
7882    const NAME: &'static str = "EntropyAck";
7883
7884    fn is_initialized(&self) -> bool {
7885        if self.entropy.is_none() {
7886            return false;
7887        }
7888        true
7889    }
7890
7891    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
7892        while let Some(tag) = is.read_raw_tag_or_eof()? {
7893            match tag {
7894                10 => {
7895                    self.entropy = ::std::option::Option::Some(is.read_bytes()?);
7896                },
7897                tag => {
7898                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
7899                },
7900            };
7901        }
7902        ::std::result::Result::Ok(())
7903    }
7904
7905    // Compute sizes of nested messages
7906    #[allow(unused_variables)]
7907    fn compute_size(&self) -> u64 {
7908        let mut my_size = 0;
7909        if let Some(v) = self.entropy.as_ref() {
7910            my_size += ::protobuf::rt::bytes_size(1, &v);
7911        }
7912        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
7913        self.special_fields.cached_size().set(my_size as u32);
7914        my_size
7915    }
7916
7917    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
7918        if let Some(v) = self.entropy.as_ref() {
7919            os.write_bytes(1, v)?;
7920        }
7921        os.write_unknown_fields(self.special_fields.unknown_fields())?;
7922        ::std::result::Result::Ok(())
7923    }
7924
7925    fn special_fields(&self) -> &::protobuf::SpecialFields {
7926        &self.special_fields
7927    }
7928
7929    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
7930        &mut self.special_fields
7931    }
7932
7933    fn new() -> EntropyAck {
7934        EntropyAck::new()
7935    }
7936
7937    fn clear(&mut self) {
7938        self.entropy = ::std::option::Option::None;
7939        self.special_fields.clear();
7940    }
7941
7942    fn default_instance() -> &'static EntropyAck {
7943        static instance: EntropyAck = EntropyAck {
7944            entropy: ::std::option::Option::None,
7945            special_fields: ::protobuf::SpecialFields::new(),
7946        };
7947        &instance
7948    }
7949}
7950
7951impl ::protobuf::MessageFull for EntropyAck {
7952    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
7953        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
7954        descriptor.get(|| file_descriptor().message_by_package_relative_name("EntropyAck").unwrap()).clone()
7955    }
7956}
7957
7958impl ::std::fmt::Display for EntropyAck {
7959    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
7960        ::protobuf::text_format::fmt(self, f)
7961    }
7962}
7963
7964impl ::protobuf::reflect::ProtobufValue for EntropyAck {
7965    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
7966}
7967
7968// @@protoc_insertion_point(message:hw.trezor.messages.management.RecoveryDevice)
7969#[derive(PartialEq,Clone,Default,Debug)]
7970pub struct RecoveryDevice {
7971    // message fields
7972    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.word_count)
7973    pub word_count: ::std::option::Option<u32>,
7974    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.passphrase_protection)
7975    pub passphrase_protection: ::std::option::Option<bool>,
7976    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.pin_protection)
7977    pub pin_protection: ::std::option::Option<bool>,
7978    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.language)
7979    pub language: ::std::option::Option<::std::string::String>,
7980    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.label)
7981    pub label: ::std::option::Option<::std::string::String>,
7982    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.enforce_wordlist)
7983    pub enforce_wordlist: ::std::option::Option<bool>,
7984    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.input_method)
7985    pub input_method: ::std::option::Option<::protobuf::EnumOrUnknown<recovery_device::RecoveryDeviceInputMethod>>,
7986    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.u2f_counter)
7987    pub u2f_counter: ::std::option::Option<u32>,
7988    // @@protoc_insertion_point(field:hw.trezor.messages.management.RecoveryDevice.type)
7989    pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<RecoveryType>>,
7990    // special fields
7991    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.RecoveryDevice.special_fields)
7992    pub special_fields: ::protobuf::SpecialFields,
7993}
7994
7995impl<'a> ::std::default::Default for &'a RecoveryDevice {
7996    fn default() -> &'a RecoveryDevice {
7997        <RecoveryDevice as ::protobuf::Message>::default_instance()
7998    }
7999}
8000
8001impl RecoveryDevice {
8002    pub fn new() -> RecoveryDevice {
8003        ::std::default::Default::default()
8004    }
8005
8006    // optional uint32 word_count = 1;
8007
8008    pub fn word_count(&self) -> u32 {
8009        self.word_count.unwrap_or(0)
8010    }
8011
8012    pub fn clear_word_count(&mut self) {
8013        self.word_count = ::std::option::Option::None;
8014    }
8015
8016    pub fn has_word_count(&self) -> bool {
8017        self.word_count.is_some()
8018    }
8019
8020    // Param is passed by value, moved
8021    pub fn set_word_count(&mut self, v: u32) {
8022        self.word_count = ::std::option::Option::Some(v);
8023    }
8024
8025    // optional bool passphrase_protection = 2;
8026
8027    pub fn passphrase_protection(&self) -> bool {
8028        self.passphrase_protection.unwrap_or(false)
8029    }
8030
8031    pub fn clear_passphrase_protection(&mut self) {
8032        self.passphrase_protection = ::std::option::Option::None;
8033    }
8034
8035    pub fn has_passphrase_protection(&self) -> bool {
8036        self.passphrase_protection.is_some()
8037    }
8038
8039    // Param is passed by value, moved
8040    pub fn set_passphrase_protection(&mut self, v: bool) {
8041        self.passphrase_protection = ::std::option::Option::Some(v);
8042    }
8043
8044    // optional bool pin_protection = 3;
8045
8046    pub fn pin_protection(&self) -> bool {
8047        self.pin_protection.unwrap_or(false)
8048    }
8049
8050    pub fn clear_pin_protection(&mut self) {
8051        self.pin_protection = ::std::option::Option::None;
8052    }
8053
8054    pub fn has_pin_protection(&self) -> bool {
8055        self.pin_protection.is_some()
8056    }
8057
8058    // Param is passed by value, moved
8059    pub fn set_pin_protection(&mut self, v: bool) {
8060        self.pin_protection = ::std::option::Option::Some(v);
8061    }
8062
8063    // optional string language = 4;
8064
8065    pub fn language(&self) -> &str {
8066        match self.language.as_ref() {
8067            Some(v) => v,
8068            None => "",
8069        }
8070    }
8071
8072    pub fn clear_language(&mut self) {
8073        self.language = ::std::option::Option::None;
8074    }
8075
8076    pub fn has_language(&self) -> bool {
8077        self.language.is_some()
8078    }
8079
8080    // Param is passed by value, moved
8081    pub fn set_language(&mut self, v: ::std::string::String) {
8082        self.language = ::std::option::Option::Some(v);
8083    }
8084
8085    // Mutable pointer to the field.
8086    // If field is not initialized, it is initialized with default value first.
8087    pub fn mut_language(&mut self) -> &mut ::std::string::String {
8088        if self.language.is_none() {
8089            self.language = ::std::option::Option::Some(::std::string::String::new());
8090        }
8091        self.language.as_mut().unwrap()
8092    }
8093
8094    // Take field
8095    pub fn take_language(&mut self) -> ::std::string::String {
8096        self.language.take().unwrap_or_else(|| ::std::string::String::new())
8097    }
8098
8099    // optional string label = 5;
8100
8101    pub fn label(&self) -> &str {
8102        match self.label.as_ref() {
8103            Some(v) => v,
8104            None => "",
8105        }
8106    }
8107
8108    pub fn clear_label(&mut self) {
8109        self.label = ::std::option::Option::None;
8110    }
8111
8112    pub fn has_label(&self) -> bool {
8113        self.label.is_some()
8114    }
8115
8116    // Param is passed by value, moved
8117    pub fn set_label(&mut self, v: ::std::string::String) {
8118        self.label = ::std::option::Option::Some(v);
8119    }
8120
8121    // Mutable pointer to the field.
8122    // If field is not initialized, it is initialized with default value first.
8123    pub fn mut_label(&mut self) -> &mut ::std::string::String {
8124        if self.label.is_none() {
8125            self.label = ::std::option::Option::Some(::std::string::String::new());
8126        }
8127        self.label.as_mut().unwrap()
8128    }
8129
8130    // Take field
8131    pub fn take_label(&mut self) -> ::std::string::String {
8132        self.label.take().unwrap_or_else(|| ::std::string::String::new())
8133    }
8134
8135    // optional bool enforce_wordlist = 6;
8136
8137    pub fn enforce_wordlist(&self) -> bool {
8138        self.enforce_wordlist.unwrap_or(false)
8139    }
8140
8141    pub fn clear_enforce_wordlist(&mut self) {
8142        self.enforce_wordlist = ::std::option::Option::None;
8143    }
8144
8145    pub fn has_enforce_wordlist(&self) -> bool {
8146        self.enforce_wordlist.is_some()
8147    }
8148
8149    // Param is passed by value, moved
8150    pub fn set_enforce_wordlist(&mut self, v: bool) {
8151        self.enforce_wordlist = ::std::option::Option::Some(v);
8152    }
8153
8154    // optional .hw.trezor.messages.management.RecoveryDevice.RecoveryDeviceInputMethod input_method = 8;
8155
8156    pub fn input_method(&self) -> recovery_device::RecoveryDeviceInputMethod {
8157        match self.input_method {
8158            Some(e) => e.enum_value_or(recovery_device::RecoveryDeviceInputMethod::ScrambledWords),
8159            None => recovery_device::RecoveryDeviceInputMethod::ScrambledWords,
8160        }
8161    }
8162
8163    pub fn clear_input_method(&mut self) {
8164        self.input_method = ::std::option::Option::None;
8165    }
8166
8167    pub fn has_input_method(&self) -> bool {
8168        self.input_method.is_some()
8169    }
8170
8171    // Param is passed by value, moved
8172    pub fn set_input_method(&mut self, v: recovery_device::RecoveryDeviceInputMethod) {
8173        self.input_method = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
8174    }
8175
8176    // optional uint32 u2f_counter = 9;
8177
8178    pub fn u2f_counter(&self) -> u32 {
8179        self.u2f_counter.unwrap_or(0)
8180    }
8181
8182    pub fn clear_u2f_counter(&mut self) {
8183        self.u2f_counter = ::std::option::Option::None;
8184    }
8185
8186    pub fn has_u2f_counter(&self) -> bool {
8187        self.u2f_counter.is_some()
8188    }
8189
8190    // Param is passed by value, moved
8191    pub fn set_u2f_counter(&mut self, v: u32) {
8192        self.u2f_counter = ::std::option::Option::Some(v);
8193    }
8194
8195    // optional .hw.trezor.messages.management.RecoveryType type = 10;
8196
8197    pub fn type_(&self) -> RecoveryType {
8198        match self.type_ {
8199            Some(e) => e.enum_value_or(RecoveryType::NormalRecovery),
8200            None => RecoveryType::NormalRecovery,
8201        }
8202    }
8203
8204    pub fn clear_type_(&mut self) {
8205        self.type_ = ::std::option::Option::None;
8206    }
8207
8208    pub fn has_type(&self) -> bool {
8209        self.type_.is_some()
8210    }
8211
8212    // Param is passed by value, moved
8213    pub fn set_type(&mut self, v: RecoveryType) {
8214        self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
8215    }
8216
8217    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
8218        let mut fields = ::std::vec::Vec::with_capacity(9);
8219        let mut oneofs = ::std::vec::Vec::with_capacity(0);
8220        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8221            "word_count",
8222            |m: &RecoveryDevice| { &m.word_count },
8223            |m: &mut RecoveryDevice| { &mut m.word_count },
8224        ));
8225        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8226            "passphrase_protection",
8227            |m: &RecoveryDevice| { &m.passphrase_protection },
8228            |m: &mut RecoveryDevice| { &mut m.passphrase_protection },
8229        ));
8230        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8231            "pin_protection",
8232            |m: &RecoveryDevice| { &m.pin_protection },
8233            |m: &mut RecoveryDevice| { &mut m.pin_protection },
8234        ));
8235        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8236            "language",
8237            |m: &RecoveryDevice| { &m.language },
8238            |m: &mut RecoveryDevice| { &mut m.language },
8239        ));
8240        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8241            "label",
8242            |m: &RecoveryDevice| { &m.label },
8243            |m: &mut RecoveryDevice| { &mut m.label },
8244        ));
8245        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8246            "enforce_wordlist",
8247            |m: &RecoveryDevice| { &m.enforce_wordlist },
8248            |m: &mut RecoveryDevice| { &mut m.enforce_wordlist },
8249        ));
8250        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8251            "input_method",
8252            |m: &RecoveryDevice| { &m.input_method },
8253            |m: &mut RecoveryDevice| { &mut m.input_method },
8254        ));
8255        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8256            "u2f_counter",
8257            |m: &RecoveryDevice| { &m.u2f_counter },
8258            |m: &mut RecoveryDevice| { &mut m.u2f_counter },
8259        ));
8260        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8261            "type",
8262            |m: &RecoveryDevice| { &m.type_ },
8263            |m: &mut RecoveryDevice| { &mut m.type_ },
8264        ));
8265        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RecoveryDevice>(
8266            "RecoveryDevice",
8267            fields,
8268            oneofs,
8269        )
8270    }
8271}
8272
8273impl ::protobuf::Message for RecoveryDevice {
8274    const NAME: &'static str = "RecoveryDevice";
8275
8276    fn is_initialized(&self) -> bool {
8277        true
8278    }
8279
8280    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
8281        while let Some(tag) = is.read_raw_tag_or_eof()? {
8282            match tag {
8283                8 => {
8284                    self.word_count = ::std::option::Option::Some(is.read_uint32()?);
8285                },
8286                16 => {
8287                    self.passphrase_protection = ::std::option::Option::Some(is.read_bool()?);
8288                },
8289                24 => {
8290                    self.pin_protection = ::std::option::Option::Some(is.read_bool()?);
8291                },
8292                34 => {
8293                    self.language = ::std::option::Option::Some(is.read_string()?);
8294                },
8295                42 => {
8296                    self.label = ::std::option::Option::Some(is.read_string()?);
8297                },
8298                48 => {
8299                    self.enforce_wordlist = ::std::option::Option::Some(is.read_bool()?);
8300                },
8301                64 => {
8302                    self.input_method = ::std::option::Option::Some(is.read_enum_or_unknown()?);
8303                },
8304                72 => {
8305                    self.u2f_counter = ::std::option::Option::Some(is.read_uint32()?);
8306                },
8307                80 => {
8308                    self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
8309                },
8310                tag => {
8311                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8312                },
8313            };
8314        }
8315        ::std::result::Result::Ok(())
8316    }
8317
8318    // Compute sizes of nested messages
8319    #[allow(unused_variables)]
8320    fn compute_size(&self) -> u64 {
8321        let mut my_size = 0;
8322        if let Some(v) = self.word_count {
8323            my_size += ::protobuf::rt::uint32_size(1, v);
8324        }
8325        if let Some(v) = self.passphrase_protection {
8326            my_size += 1 + 1;
8327        }
8328        if let Some(v) = self.pin_protection {
8329            my_size += 1 + 1;
8330        }
8331        if let Some(v) = self.language.as_ref() {
8332            my_size += ::protobuf::rt::string_size(4, &v);
8333        }
8334        if let Some(v) = self.label.as_ref() {
8335            my_size += ::protobuf::rt::string_size(5, &v);
8336        }
8337        if let Some(v) = self.enforce_wordlist {
8338            my_size += 1 + 1;
8339        }
8340        if let Some(v) = self.input_method {
8341            my_size += ::protobuf::rt::int32_size(8, v.value());
8342        }
8343        if let Some(v) = self.u2f_counter {
8344            my_size += ::protobuf::rt::uint32_size(9, v);
8345        }
8346        if let Some(v) = self.type_ {
8347            my_size += ::protobuf::rt::int32_size(10, v.value());
8348        }
8349        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
8350        self.special_fields.cached_size().set(my_size as u32);
8351        my_size
8352    }
8353
8354    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
8355        if let Some(v) = self.word_count {
8356            os.write_uint32(1, v)?;
8357        }
8358        if let Some(v) = self.passphrase_protection {
8359            os.write_bool(2, v)?;
8360        }
8361        if let Some(v) = self.pin_protection {
8362            os.write_bool(3, v)?;
8363        }
8364        if let Some(v) = self.language.as_ref() {
8365            os.write_string(4, v)?;
8366        }
8367        if let Some(v) = self.label.as_ref() {
8368            os.write_string(5, v)?;
8369        }
8370        if let Some(v) = self.enforce_wordlist {
8371            os.write_bool(6, v)?;
8372        }
8373        if let Some(v) = self.input_method {
8374            os.write_enum(8, ::protobuf::EnumOrUnknown::value(&v))?;
8375        }
8376        if let Some(v) = self.u2f_counter {
8377            os.write_uint32(9, v)?;
8378        }
8379        if let Some(v) = self.type_ {
8380            os.write_enum(10, ::protobuf::EnumOrUnknown::value(&v))?;
8381        }
8382        os.write_unknown_fields(self.special_fields.unknown_fields())?;
8383        ::std::result::Result::Ok(())
8384    }
8385
8386    fn special_fields(&self) -> &::protobuf::SpecialFields {
8387        &self.special_fields
8388    }
8389
8390    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
8391        &mut self.special_fields
8392    }
8393
8394    fn new() -> RecoveryDevice {
8395        RecoveryDevice::new()
8396    }
8397
8398    fn clear(&mut self) {
8399        self.word_count = ::std::option::Option::None;
8400        self.passphrase_protection = ::std::option::Option::None;
8401        self.pin_protection = ::std::option::Option::None;
8402        self.language = ::std::option::Option::None;
8403        self.label = ::std::option::Option::None;
8404        self.enforce_wordlist = ::std::option::Option::None;
8405        self.input_method = ::std::option::Option::None;
8406        self.u2f_counter = ::std::option::Option::None;
8407        self.type_ = ::std::option::Option::None;
8408        self.special_fields.clear();
8409    }
8410
8411    fn default_instance() -> &'static RecoveryDevice {
8412        static instance: RecoveryDevice = RecoveryDevice {
8413            word_count: ::std::option::Option::None,
8414            passphrase_protection: ::std::option::Option::None,
8415            pin_protection: ::std::option::Option::None,
8416            language: ::std::option::Option::None,
8417            label: ::std::option::Option::None,
8418            enforce_wordlist: ::std::option::Option::None,
8419            input_method: ::std::option::Option::None,
8420            u2f_counter: ::std::option::Option::None,
8421            type_: ::std::option::Option::None,
8422            special_fields: ::protobuf::SpecialFields::new(),
8423        };
8424        &instance
8425    }
8426}
8427
8428impl ::protobuf::MessageFull for RecoveryDevice {
8429    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
8430        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
8431        descriptor.get(|| file_descriptor().message_by_package_relative_name("RecoveryDevice").unwrap()).clone()
8432    }
8433}
8434
8435impl ::std::fmt::Display for RecoveryDevice {
8436    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8437        ::protobuf::text_format::fmt(self, f)
8438    }
8439}
8440
8441impl ::protobuf::reflect::ProtobufValue for RecoveryDevice {
8442    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
8443}
8444
8445/// Nested message and enums of message `RecoveryDevice`
8446pub mod recovery_device {
8447    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
8448    // @@protoc_insertion_point(enum:hw.trezor.messages.management.RecoveryDevice.RecoveryDeviceInputMethod)
8449    pub enum RecoveryDeviceInputMethod {
8450        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RecoveryDevice.RecoveryDeviceInputMethod.ScrambledWords)
8451        ScrambledWords = 0,
8452        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RecoveryDevice.RecoveryDeviceInputMethod.Matrix)
8453        Matrix = 1,
8454    }
8455
8456    impl ::protobuf::Enum for RecoveryDeviceInputMethod {
8457        const NAME: &'static str = "RecoveryDeviceInputMethod";
8458
8459        fn value(&self) -> i32 {
8460            *self as i32
8461        }
8462
8463        fn from_i32(value: i32) -> ::std::option::Option<RecoveryDeviceInputMethod> {
8464            match value {
8465                0 => ::std::option::Option::Some(RecoveryDeviceInputMethod::ScrambledWords),
8466                1 => ::std::option::Option::Some(RecoveryDeviceInputMethod::Matrix),
8467                _ => ::std::option::Option::None
8468            }
8469        }
8470
8471        fn from_str(str: &str) -> ::std::option::Option<RecoveryDeviceInputMethod> {
8472            match str {
8473                "ScrambledWords" => ::std::option::Option::Some(RecoveryDeviceInputMethod::ScrambledWords),
8474                "Matrix" => ::std::option::Option::Some(RecoveryDeviceInputMethod::Matrix),
8475                _ => ::std::option::Option::None
8476            }
8477        }
8478
8479        const VALUES: &'static [RecoveryDeviceInputMethod] = &[
8480            RecoveryDeviceInputMethod::ScrambledWords,
8481            RecoveryDeviceInputMethod::Matrix,
8482        ];
8483    }
8484
8485    impl ::protobuf::EnumFull for RecoveryDeviceInputMethod {
8486        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
8487            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
8488            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("RecoveryDevice.RecoveryDeviceInputMethod").unwrap()).clone()
8489        }
8490
8491        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
8492            let index = *self as usize;
8493            Self::enum_descriptor().value_by_index(index)
8494        }
8495    }
8496
8497    impl ::std::default::Default for RecoveryDeviceInputMethod {
8498        fn default() -> Self {
8499            RecoveryDeviceInputMethod::ScrambledWords
8500        }
8501    }
8502
8503    impl RecoveryDeviceInputMethod {
8504        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
8505            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<RecoveryDeviceInputMethod>("RecoveryDevice.RecoveryDeviceInputMethod")
8506        }
8507    }
8508}
8509
8510// @@protoc_insertion_point(message:hw.trezor.messages.management.WordRequest)
8511#[derive(PartialEq,Clone,Default,Debug)]
8512pub struct WordRequest {
8513    // message fields
8514    // @@protoc_insertion_point(field:hw.trezor.messages.management.WordRequest.type)
8515    pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<word_request::WordRequestType>>,
8516    // special fields
8517    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.WordRequest.special_fields)
8518    pub special_fields: ::protobuf::SpecialFields,
8519}
8520
8521impl<'a> ::std::default::Default for &'a WordRequest {
8522    fn default() -> &'a WordRequest {
8523        <WordRequest as ::protobuf::Message>::default_instance()
8524    }
8525}
8526
8527impl WordRequest {
8528    pub fn new() -> WordRequest {
8529        ::std::default::Default::default()
8530    }
8531
8532    // required .hw.trezor.messages.management.WordRequest.WordRequestType type = 1;
8533
8534    pub fn type_(&self) -> word_request::WordRequestType {
8535        match self.type_ {
8536            Some(e) => e.enum_value_or(word_request::WordRequestType::WordRequestType_Plain),
8537            None => word_request::WordRequestType::WordRequestType_Plain,
8538        }
8539    }
8540
8541    pub fn clear_type_(&mut self) {
8542        self.type_ = ::std::option::Option::None;
8543    }
8544
8545    pub fn has_type(&self) -> bool {
8546        self.type_.is_some()
8547    }
8548
8549    // Param is passed by value, moved
8550    pub fn set_type(&mut self, v: word_request::WordRequestType) {
8551        self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
8552    }
8553
8554    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
8555        let mut fields = ::std::vec::Vec::with_capacity(1);
8556        let mut oneofs = ::std::vec::Vec::with_capacity(0);
8557        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8558            "type",
8559            |m: &WordRequest| { &m.type_ },
8560            |m: &mut WordRequest| { &mut m.type_ },
8561        ));
8562        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<WordRequest>(
8563            "WordRequest",
8564            fields,
8565            oneofs,
8566        )
8567    }
8568}
8569
8570impl ::protobuf::Message for WordRequest {
8571    const NAME: &'static str = "WordRequest";
8572
8573    fn is_initialized(&self) -> bool {
8574        if self.type_.is_none() {
8575            return false;
8576        }
8577        true
8578    }
8579
8580    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
8581        while let Some(tag) = is.read_raw_tag_or_eof()? {
8582            match tag {
8583                8 => {
8584                    self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
8585                },
8586                tag => {
8587                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8588                },
8589            };
8590        }
8591        ::std::result::Result::Ok(())
8592    }
8593
8594    // Compute sizes of nested messages
8595    #[allow(unused_variables)]
8596    fn compute_size(&self) -> u64 {
8597        let mut my_size = 0;
8598        if let Some(v) = self.type_ {
8599            my_size += ::protobuf::rt::int32_size(1, v.value());
8600        }
8601        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
8602        self.special_fields.cached_size().set(my_size as u32);
8603        my_size
8604    }
8605
8606    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
8607        if let Some(v) = self.type_ {
8608            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
8609        }
8610        os.write_unknown_fields(self.special_fields.unknown_fields())?;
8611        ::std::result::Result::Ok(())
8612    }
8613
8614    fn special_fields(&self) -> &::protobuf::SpecialFields {
8615        &self.special_fields
8616    }
8617
8618    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
8619        &mut self.special_fields
8620    }
8621
8622    fn new() -> WordRequest {
8623        WordRequest::new()
8624    }
8625
8626    fn clear(&mut self) {
8627        self.type_ = ::std::option::Option::None;
8628        self.special_fields.clear();
8629    }
8630
8631    fn default_instance() -> &'static WordRequest {
8632        static instance: WordRequest = WordRequest {
8633            type_: ::std::option::Option::None,
8634            special_fields: ::protobuf::SpecialFields::new(),
8635        };
8636        &instance
8637    }
8638}
8639
8640impl ::protobuf::MessageFull for WordRequest {
8641    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
8642        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
8643        descriptor.get(|| file_descriptor().message_by_package_relative_name("WordRequest").unwrap()).clone()
8644    }
8645}
8646
8647impl ::std::fmt::Display for WordRequest {
8648    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8649        ::protobuf::text_format::fmt(self, f)
8650    }
8651}
8652
8653impl ::protobuf::reflect::ProtobufValue for WordRequest {
8654    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
8655}
8656
8657/// Nested message and enums of message `WordRequest`
8658pub mod word_request {
8659    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
8660    // @@protoc_insertion_point(enum:hw.trezor.messages.management.WordRequest.WordRequestType)
8661    pub enum WordRequestType {
8662        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.WordRequest.WordRequestType.WordRequestType_Plain)
8663        WordRequestType_Plain = 0,
8664        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.WordRequest.WordRequestType.WordRequestType_Matrix9)
8665        WordRequestType_Matrix9 = 1,
8666        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.WordRequest.WordRequestType.WordRequestType_Matrix6)
8667        WordRequestType_Matrix6 = 2,
8668    }
8669
8670    impl ::protobuf::Enum for WordRequestType {
8671        const NAME: &'static str = "WordRequestType";
8672
8673        fn value(&self) -> i32 {
8674            *self as i32
8675        }
8676
8677        fn from_i32(value: i32) -> ::std::option::Option<WordRequestType> {
8678            match value {
8679                0 => ::std::option::Option::Some(WordRequestType::WordRequestType_Plain),
8680                1 => ::std::option::Option::Some(WordRequestType::WordRequestType_Matrix9),
8681                2 => ::std::option::Option::Some(WordRequestType::WordRequestType_Matrix6),
8682                _ => ::std::option::Option::None
8683            }
8684        }
8685
8686        fn from_str(str: &str) -> ::std::option::Option<WordRequestType> {
8687            match str {
8688                "WordRequestType_Plain" => ::std::option::Option::Some(WordRequestType::WordRequestType_Plain),
8689                "WordRequestType_Matrix9" => ::std::option::Option::Some(WordRequestType::WordRequestType_Matrix9),
8690                "WordRequestType_Matrix6" => ::std::option::Option::Some(WordRequestType::WordRequestType_Matrix6),
8691                _ => ::std::option::Option::None
8692            }
8693        }
8694
8695        const VALUES: &'static [WordRequestType] = &[
8696            WordRequestType::WordRequestType_Plain,
8697            WordRequestType::WordRequestType_Matrix9,
8698            WordRequestType::WordRequestType_Matrix6,
8699        ];
8700    }
8701
8702    impl ::protobuf::EnumFull for WordRequestType {
8703        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
8704            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
8705            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("WordRequest.WordRequestType").unwrap()).clone()
8706        }
8707
8708        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
8709            let index = *self as usize;
8710            Self::enum_descriptor().value_by_index(index)
8711        }
8712    }
8713
8714    impl ::std::default::Default for WordRequestType {
8715        fn default() -> Self {
8716            WordRequestType::WordRequestType_Plain
8717        }
8718    }
8719
8720    impl WordRequestType {
8721        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
8722            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<WordRequestType>("WordRequest.WordRequestType")
8723        }
8724    }
8725}
8726
8727// @@protoc_insertion_point(message:hw.trezor.messages.management.WordAck)
8728#[derive(PartialEq,Clone,Default,Debug)]
8729pub struct WordAck {
8730    // message fields
8731    // @@protoc_insertion_point(field:hw.trezor.messages.management.WordAck.word)
8732    pub word: ::std::option::Option<::std::string::String>,
8733    // special fields
8734    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.WordAck.special_fields)
8735    pub special_fields: ::protobuf::SpecialFields,
8736}
8737
8738impl<'a> ::std::default::Default for &'a WordAck {
8739    fn default() -> &'a WordAck {
8740        <WordAck as ::protobuf::Message>::default_instance()
8741    }
8742}
8743
8744impl WordAck {
8745    pub fn new() -> WordAck {
8746        ::std::default::Default::default()
8747    }
8748
8749    // required string word = 1;
8750
8751    pub fn word(&self) -> &str {
8752        match self.word.as_ref() {
8753            Some(v) => v,
8754            None => "",
8755        }
8756    }
8757
8758    pub fn clear_word(&mut self) {
8759        self.word = ::std::option::Option::None;
8760    }
8761
8762    pub fn has_word(&self) -> bool {
8763        self.word.is_some()
8764    }
8765
8766    // Param is passed by value, moved
8767    pub fn set_word(&mut self, v: ::std::string::String) {
8768        self.word = ::std::option::Option::Some(v);
8769    }
8770
8771    // Mutable pointer to the field.
8772    // If field is not initialized, it is initialized with default value first.
8773    pub fn mut_word(&mut self) -> &mut ::std::string::String {
8774        if self.word.is_none() {
8775            self.word = ::std::option::Option::Some(::std::string::String::new());
8776        }
8777        self.word.as_mut().unwrap()
8778    }
8779
8780    // Take field
8781    pub fn take_word(&mut self) -> ::std::string::String {
8782        self.word.take().unwrap_or_else(|| ::std::string::String::new())
8783    }
8784
8785    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
8786        let mut fields = ::std::vec::Vec::with_capacity(1);
8787        let mut oneofs = ::std::vec::Vec::with_capacity(0);
8788        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8789            "word",
8790            |m: &WordAck| { &m.word },
8791            |m: &mut WordAck| { &mut m.word },
8792        ));
8793        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<WordAck>(
8794            "WordAck",
8795            fields,
8796            oneofs,
8797        )
8798    }
8799}
8800
8801impl ::protobuf::Message for WordAck {
8802    const NAME: &'static str = "WordAck";
8803
8804    fn is_initialized(&self) -> bool {
8805        if self.word.is_none() {
8806            return false;
8807        }
8808        true
8809    }
8810
8811    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
8812        while let Some(tag) = is.read_raw_tag_or_eof()? {
8813            match tag {
8814                10 => {
8815                    self.word = ::std::option::Option::Some(is.read_string()?);
8816                },
8817                tag => {
8818                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8819                },
8820            };
8821        }
8822        ::std::result::Result::Ok(())
8823    }
8824
8825    // Compute sizes of nested messages
8826    #[allow(unused_variables)]
8827    fn compute_size(&self) -> u64 {
8828        let mut my_size = 0;
8829        if let Some(v) = self.word.as_ref() {
8830            my_size += ::protobuf::rt::string_size(1, &v);
8831        }
8832        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
8833        self.special_fields.cached_size().set(my_size as u32);
8834        my_size
8835    }
8836
8837    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
8838        if let Some(v) = self.word.as_ref() {
8839            os.write_string(1, v)?;
8840        }
8841        os.write_unknown_fields(self.special_fields.unknown_fields())?;
8842        ::std::result::Result::Ok(())
8843    }
8844
8845    fn special_fields(&self) -> &::protobuf::SpecialFields {
8846        &self.special_fields
8847    }
8848
8849    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
8850        &mut self.special_fields
8851    }
8852
8853    fn new() -> WordAck {
8854        WordAck::new()
8855    }
8856
8857    fn clear(&mut self) {
8858        self.word = ::std::option::Option::None;
8859        self.special_fields.clear();
8860    }
8861
8862    fn default_instance() -> &'static WordAck {
8863        static instance: WordAck = WordAck {
8864            word: ::std::option::Option::None,
8865            special_fields: ::protobuf::SpecialFields::new(),
8866        };
8867        &instance
8868    }
8869}
8870
8871impl ::protobuf::MessageFull for WordAck {
8872    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
8873        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
8874        descriptor.get(|| file_descriptor().message_by_package_relative_name("WordAck").unwrap()).clone()
8875    }
8876}
8877
8878impl ::std::fmt::Display for WordAck {
8879    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
8880        ::protobuf::text_format::fmt(self, f)
8881    }
8882}
8883
8884impl ::protobuf::reflect::ProtobufValue for WordAck {
8885    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
8886}
8887
8888// @@protoc_insertion_point(message:hw.trezor.messages.management.SetU2FCounter)
8889#[derive(PartialEq,Clone,Default,Debug)]
8890pub struct SetU2FCounter {
8891    // message fields
8892    // @@protoc_insertion_point(field:hw.trezor.messages.management.SetU2FCounter.u2f_counter)
8893    pub u2f_counter: ::std::option::Option<u32>,
8894    // special fields
8895    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.SetU2FCounter.special_fields)
8896    pub special_fields: ::protobuf::SpecialFields,
8897}
8898
8899impl<'a> ::std::default::Default for &'a SetU2FCounter {
8900    fn default() -> &'a SetU2FCounter {
8901        <SetU2FCounter as ::protobuf::Message>::default_instance()
8902    }
8903}
8904
8905impl SetU2FCounter {
8906    pub fn new() -> SetU2FCounter {
8907        ::std::default::Default::default()
8908    }
8909
8910    // required uint32 u2f_counter = 1;
8911
8912    pub fn u2f_counter(&self) -> u32 {
8913        self.u2f_counter.unwrap_or(0)
8914    }
8915
8916    pub fn clear_u2f_counter(&mut self) {
8917        self.u2f_counter = ::std::option::Option::None;
8918    }
8919
8920    pub fn has_u2f_counter(&self) -> bool {
8921        self.u2f_counter.is_some()
8922    }
8923
8924    // Param is passed by value, moved
8925    pub fn set_u2f_counter(&mut self, v: u32) {
8926        self.u2f_counter = ::std::option::Option::Some(v);
8927    }
8928
8929    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
8930        let mut fields = ::std::vec::Vec::with_capacity(1);
8931        let mut oneofs = ::std::vec::Vec::with_capacity(0);
8932        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
8933            "u2f_counter",
8934            |m: &SetU2FCounter| { &m.u2f_counter },
8935            |m: &mut SetU2FCounter| { &mut m.u2f_counter },
8936        ));
8937        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetU2FCounter>(
8938            "SetU2FCounter",
8939            fields,
8940            oneofs,
8941        )
8942    }
8943}
8944
8945impl ::protobuf::Message for SetU2FCounter {
8946    const NAME: &'static str = "SetU2FCounter";
8947
8948    fn is_initialized(&self) -> bool {
8949        if self.u2f_counter.is_none() {
8950            return false;
8951        }
8952        true
8953    }
8954
8955    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
8956        while let Some(tag) = is.read_raw_tag_or_eof()? {
8957            match tag {
8958                8 => {
8959                    self.u2f_counter = ::std::option::Option::Some(is.read_uint32()?);
8960                },
8961                tag => {
8962                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
8963                },
8964            };
8965        }
8966        ::std::result::Result::Ok(())
8967    }
8968
8969    // Compute sizes of nested messages
8970    #[allow(unused_variables)]
8971    fn compute_size(&self) -> u64 {
8972        let mut my_size = 0;
8973        if let Some(v) = self.u2f_counter {
8974            my_size += ::protobuf::rt::uint32_size(1, v);
8975        }
8976        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
8977        self.special_fields.cached_size().set(my_size as u32);
8978        my_size
8979    }
8980
8981    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
8982        if let Some(v) = self.u2f_counter {
8983            os.write_uint32(1, v)?;
8984        }
8985        os.write_unknown_fields(self.special_fields.unknown_fields())?;
8986        ::std::result::Result::Ok(())
8987    }
8988
8989    fn special_fields(&self) -> &::protobuf::SpecialFields {
8990        &self.special_fields
8991    }
8992
8993    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
8994        &mut self.special_fields
8995    }
8996
8997    fn new() -> SetU2FCounter {
8998        SetU2FCounter::new()
8999    }
9000
9001    fn clear(&mut self) {
9002        self.u2f_counter = ::std::option::Option::None;
9003        self.special_fields.clear();
9004    }
9005
9006    fn default_instance() -> &'static SetU2FCounter {
9007        static instance: SetU2FCounter = SetU2FCounter {
9008            u2f_counter: ::std::option::Option::None,
9009            special_fields: ::protobuf::SpecialFields::new(),
9010        };
9011        &instance
9012    }
9013}
9014
9015impl ::protobuf::MessageFull for SetU2FCounter {
9016    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9017        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9018        descriptor.get(|| file_descriptor().message_by_package_relative_name("SetU2FCounter").unwrap()).clone()
9019    }
9020}
9021
9022impl ::std::fmt::Display for SetU2FCounter {
9023    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9024        ::protobuf::text_format::fmt(self, f)
9025    }
9026}
9027
9028impl ::protobuf::reflect::ProtobufValue for SetU2FCounter {
9029    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9030}
9031
9032// @@protoc_insertion_point(message:hw.trezor.messages.management.GetNextU2FCounter)
9033#[derive(PartialEq,Clone,Default,Debug)]
9034pub struct GetNextU2FCounter {
9035    // special fields
9036    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.GetNextU2FCounter.special_fields)
9037    pub special_fields: ::protobuf::SpecialFields,
9038}
9039
9040impl<'a> ::std::default::Default for &'a GetNextU2FCounter {
9041    fn default() -> &'a GetNextU2FCounter {
9042        <GetNextU2FCounter as ::protobuf::Message>::default_instance()
9043    }
9044}
9045
9046impl GetNextU2FCounter {
9047    pub fn new() -> GetNextU2FCounter {
9048        ::std::default::Default::default()
9049    }
9050
9051    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9052        let mut fields = ::std::vec::Vec::with_capacity(0);
9053        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9054        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetNextU2FCounter>(
9055            "GetNextU2FCounter",
9056            fields,
9057            oneofs,
9058        )
9059    }
9060}
9061
9062impl ::protobuf::Message for GetNextU2FCounter {
9063    const NAME: &'static str = "GetNextU2FCounter";
9064
9065    fn is_initialized(&self) -> bool {
9066        true
9067    }
9068
9069    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9070        while let Some(tag) = is.read_raw_tag_or_eof()? {
9071            match tag {
9072                tag => {
9073                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9074                },
9075            };
9076        }
9077        ::std::result::Result::Ok(())
9078    }
9079
9080    // Compute sizes of nested messages
9081    #[allow(unused_variables)]
9082    fn compute_size(&self) -> u64 {
9083        let mut my_size = 0;
9084        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9085        self.special_fields.cached_size().set(my_size as u32);
9086        my_size
9087    }
9088
9089    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9090        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9091        ::std::result::Result::Ok(())
9092    }
9093
9094    fn special_fields(&self) -> &::protobuf::SpecialFields {
9095        &self.special_fields
9096    }
9097
9098    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9099        &mut self.special_fields
9100    }
9101
9102    fn new() -> GetNextU2FCounter {
9103        GetNextU2FCounter::new()
9104    }
9105
9106    fn clear(&mut self) {
9107        self.special_fields.clear();
9108    }
9109
9110    fn default_instance() -> &'static GetNextU2FCounter {
9111        static instance: GetNextU2FCounter = GetNextU2FCounter {
9112            special_fields: ::protobuf::SpecialFields::new(),
9113        };
9114        &instance
9115    }
9116}
9117
9118impl ::protobuf::MessageFull for GetNextU2FCounter {
9119    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9120        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9121        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetNextU2FCounter").unwrap()).clone()
9122    }
9123}
9124
9125impl ::std::fmt::Display for GetNextU2FCounter {
9126    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9127        ::protobuf::text_format::fmt(self, f)
9128    }
9129}
9130
9131impl ::protobuf::reflect::ProtobufValue for GetNextU2FCounter {
9132    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9133}
9134
9135// @@protoc_insertion_point(message:hw.trezor.messages.management.NextU2FCounter)
9136#[derive(PartialEq,Clone,Default,Debug)]
9137pub struct NextU2FCounter {
9138    // message fields
9139    // @@protoc_insertion_point(field:hw.trezor.messages.management.NextU2FCounter.u2f_counter)
9140    pub u2f_counter: ::std::option::Option<u32>,
9141    // special fields
9142    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.NextU2FCounter.special_fields)
9143    pub special_fields: ::protobuf::SpecialFields,
9144}
9145
9146impl<'a> ::std::default::Default for &'a NextU2FCounter {
9147    fn default() -> &'a NextU2FCounter {
9148        <NextU2FCounter as ::protobuf::Message>::default_instance()
9149    }
9150}
9151
9152impl NextU2FCounter {
9153    pub fn new() -> NextU2FCounter {
9154        ::std::default::Default::default()
9155    }
9156
9157    // required uint32 u2f_counter = 1;
9158
9159    pub fn u2f_counter(&self) -> u32 {
9160        self.u2f_counter.unwrap_or(0)
9161    }
9162
9163    pub fn clear_u2f_counter(&mut self) {
9164        self.u2f_counter = ::std::option::Option::None;
9165    }
9166
9167    pub fn has_u2f_counter(&self) -> bool {
9168        self.u2f_counter.is_some()
9169    }
9170
9171    // Param is passed by value, moved
9172    pub fn set_u2f_counter(&mut self, v: u32) {
9173        self.u2f_counter = ::std::option::Option::Some(v);
9174    }
9175
9176    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9177        let mut fields = ::std::vec::Vec::with_capacity(1);
9178        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9179        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
9180            "u2f_counter",
9181            |m: &NextU2FCounter| { &m.u2f_counter },
9182            |m: &mut NextU2FCounter| { &mut m.u2f_counter },
9183        ));
9184        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<NextU2FCounter>(
9185            "NextU2FCounter",
9186            fields,
9187            oneofs,
9188        )
9189    }
9190}
9191
9192impl ::protobuf::Message for NextU2FCounter {
9193    const NAME: &'static str = "NextU2FCounter";
9194
9195    fn is_initialized(&self) -> bool {
9196        if self.u2f_counter.is_none() {
9197            return false;
9198        }
9199        true
9200    }
9201
9202    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9203        while let Some(tag) = is.read_raw_tag_or_eof()? {
9204            match tag {
9205                8 => {
9206                    self.u2f_counter = ::std::option::Option::Some(is.read_uint32()?);
9207                },
9208                tag => {
9209                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9210                },
9211            };
9212        }
9213        ::std::result::Result::Ok(())
9214    }
9215
9216    // Compute sizes of nested messages
9217    #[allow(unused_variables)]
9218    fn compute_size(&self) -> u64 {
9219        let mut my_size = 0;
9220        if let Some(v) = self.u2f_counter {
9221            my_size += ::protobuf::rt::uint32_size(1, v);
9222        }
9223        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9224        self.special_fields.cached_size().set(my_size as u32);
9225        my_size
9226    }
9227
9228    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9229        if let Some(v) = self.u2f_counter {
9230            os.write_uint32(1, v)?;
9231        }
9232        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9233        ::std::result::Result::Ok(())
9234    }
9235
9236    fn special_fields(&self) -> &::protobuf::SpecialFields {
9237        &self.special_fields
9238    }
9239
9240    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9241        &mut self.special_fields
9242    }
9243
9244    fn new() -> NextU2FCounter {
9245        NextU2FCounter::new()
9246    }
9247
9248    fn clear(&mut self) {
9249        self.u2f_counter = ::std::option::Option::None;
9250        self.special_fields.clear();
9251    }
9252
9253    fn default_instance() -> &'static NextU2FCounter {
9254        static instance: NextU2FCounter = NextU2FCounter {
9255            u2f_counter: ::std::option::Option::None,
9256            special_fields: ::protobuf::SpecialFields::new(),
9257        };
9258        &instance
9259    }
9260}
9261
9262impl ::protobuf::MessageFull for NextU2FCounter {
9263    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9264        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9265        descriptor.get(|| file_descriptor().message_by_package_relative_name("NextU2FCounter").unwrap()).clone()
9266    }
9267}
9268
9269impl ::std::fmt::Display for NextU2FCounter {
9270    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9271        ::protobuf::text_format::fmt(self, f)
9272    }
9273}
9274
9275impl ::protobuf::reflect::ProtobufValue for NextU2FCounter {
9276    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9277}
9278
9279// @@protoc_insertion_point(message:hw.trezor.messages.management.DoPreauthorized)
9280#[derive(PartialEq,Clone,Default,Debug)]
9281pub struct DoPreauthorized {
9282    // special fields
9283    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.DoPreauthorized.special_fields)
9284    pub special_fields: ::protobuf::SpecialFields,
9285}
9286
9287impl<'a> ::std::default::Default for &'a DoPreauthorized {
9288    fn default() -> &'a DoPreauthorized {
9289        <DoPreauthorized as ::protobuf::Message>::default_instance()
9290    }
9291}
9292
9293impl DoPreauthorized {
9294    pub fn new() -> DoPreauthorized {
9295        ::std::default::Default::default()
9296    }
9297
9298    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9299        let mut fields = ::std::vec::Vec::with_capacity(0);
9300        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9301        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<DoPreauthorized>(
9302            "DoPreauthorized",
9303            fields,
9304            oneofs,
9305        )
9306    }
9307}
9308
9309impl ::protobuf::Message for DoPreauthorized {
9310    const NAME: &'static str = "DoPreauthorized";
9311
9312    fn is_initialized(&self) -> bool {
9313        true
9314    }
9315
9316    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9317        while let Some(tag) = is.read_raw_tag_or_eof()? {
9318            match tag {
9319                tag => {
9320                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9321                },
9322            };
9323        }
9324        ::std::result::Result::Ok(())
9325    }
9326
9327    // Compute sizes of nested messages
9328    #[allow(unused_variables)]
9329    fn compute_size(&self) -> u64 {
9330        let mut my_size = 0;
9331        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9332        self.special_fields.cached_size().set(my_size as u32);
9333        my_size
9334    }
9335
9336    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9337        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9338        ::std::result::Result::Ok(())
9339    }
9340
9341    fn special_fields(&self) -> &::protobuf::SpecialFields {
9342        &self.special_fields
9343    }
9344
9345    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9346        &mut self.special_fields
9347    }
9348
9349    fn new() -> DoPreauthorized {
9350        DoPreauthorized::new()
9351    }
9352
9353    fn clear(&mut self) {
9354        self.special_fields.clear();
9355    }
9356
9357    fn default_instance() -> &'static DoPreauthorized {
9358        static instance: DoPreauthorized = DoPreauthorized {
9359            special_fields: ::protobuf::SpecialFields::new(),
9360        };
9361        &instance
9362    }
9363}
9364
9365impl ::protobuf::MessageFull for DoPreauthorized {
9366    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9367        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9368        descriptor.get(|| file_descriptor().message_by_package_relative_name("DoPreauthorized").unwrap()).clone()
9369    }
9370}
9371
9372impl ::std::fmt::Display for DoPreauthorized {
9373    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9374        ::protobuf::text_format::fmt(self, f)
9375    }
9376}
9377
9378impl ::protobuf::reflect::ProtobufValue for DoPreauthorized {
9379    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9380}
9381
9382// @@protoc_insertion_point(message:hw.trezor.messages.management.PreauthorizedRequest)
9383#[derive(PartialEq,Clone,Default,Debug)]
9384pub struct PreauthorizedRequest {
9385    // special fields
9386    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.PreauthorizedRequest.special_fields)
9387    pub special_fields: ::protobuf::SpecialFields,
9388}
9389
9390impl<'a> ::std::default::Default for &'a PreauthorizedRequest {
9391    fn default() -> &'a PreauthorizedRequest {
9392        <PreauthorizedRequest as ::protobuf::Message>::default_instance()
9393    }
9394}
9395
9396impl PreauthorizedRequest {
9397    pub fn new() -> PreauthorizedRequest {
9398        ::std::default::Default::default()
9399    }
9400
9401    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9402        let mut fields = ::std::vec::Vec::with_capacity(0);
9403        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9404        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PreauthorizedRequest>(
9405            "PreauthorizedRequest",
9406            fields,
9407            oneofs,
9408        )
9409    }
9410}
9411
9412impl ::protobuf::Message for PreauthorizedRequest {
9413    const NAME: &'static str = "PreauthorizedRequest";
9414
9415    fn is_initialized(&self) -> bool {
9416        true
9417    }
9418
9419    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9420        while let Some(tag) = is.read_raw_tag_or_eof()? {
9421            match tag {
9422                tag => {
9423                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9424                },
9425            };
9426        }
9427        ::std::result::Result::Ok(())
9428    }
9429
9430    // Compute sizes of nested messages
9431    #[allow(unused_variables)]
9432    fn compute_size(&self) -> u64 {
9433        let mut my_size = 0;
9434        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9435        self.special_fields.cached_size().set(my_size as u32);
9436        my_size
9437    }
9438
9439    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9440        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9441        ::std::result::Result::Ok(())
9442    }
9443
9444    fn special_fields(&self) -> &::protobuf::SpecialFields {
9445        &self.special_fields
9446    }
9447
9448    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9449        &mut self.special_fields
9450    }
9451
9452    fn new() -> PreauthorizedRequest {
9453        PreauthorizedRequest::new()
9454    }
9455
9456    fn clear(&mut self) {
9457        self.special_fields.clear();
9458    }
9459
9460    fn default_instance() -> &'static PreauthorizedRequest {
9461        static instance: PreauthorizedRequest = PreauthorizedRequest {
9462            special_fields: ::protobuf::SpecialFields::new(),
9463        };
9464        &instance
9465    }
9466}
9467
9468impl ::protobuf::MessageFull for PreauthorizedRequest {
9469    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9470        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9471        descriptor.get(|| file_descriptor().message_by_package_relative_name("PreauthorizedRequest").unwrap()).clone()
9472    }
9473}
9474
9475impl ::std::fmt::Display for PreauthorizedRequest {
9476    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9477        ::protobuf::text_format::fmt(self, f)
9478    }
9479}
9480
9481impl ::protobuf::reflect::ProtobufValue for PreauthorizedRequest {
9482    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9483}
9484
9485// @@protoc_insertion_point(message:hw.trezor.messages.management.CancelAuthorization)
9486#[derive(PartialEq,Clone,Default,Debug)]
9487pub struct CancelAuthorization {
9488    // special fields
9489    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.CancelAuthorization.special_fields)
9490    pub special_fields: ::protobuf::SpecialFields,
9491}
9492
9493impl<'a> ::std::default::Default for &'a CancelAuthorization {
9494    fn default() -> &'a CancelAuthorization {
9495        <CancelAuthorization as ::protobuf::Message>::default_instance()
9496    }
9497}
9498
9499impl CancelAuthorization {
9500    pub fn new() -> CancelAuthorization {
9501        ::std::default::Default::default()
9502    }
9503
9504    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9505        let mut fields = ::std::vec::Vec::with_capacity(0);
9506        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9507        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<CancelAuthorization>(
9508            "CancelAuthorization",
9509            fields,
9510            oneofs,
9511        )
9512    }
9513}
9514
9515impl ::protobuf::Message for CancelAuthorization {
9516    const NAME: &'static str = "CancelAuthorization";
9517
9518    fn is_initialized(&self) -> bool {
9519        true
9520    }
9521
9522    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9523        while let Some(tag) = is.read_raw_tag_or_eof()? {
9524            match tag {
9525                tag => {
9526                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9527                },
9528            };
9529        }
9530        ::std::result::Result::Ok(())
9531    }
9532
9533    // Compute sizes of nested messages
9534    #[allow(unused_variables)]
9535    fn compute_size(&self) -> u64 {
9536        let mut my_size = 0;
9537        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9538        self.special_fields.cached_size().set(my_size as u32);
9539        my_size
9540    }
9541
9542    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9543        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9544        ::std::result::Result::Ok(())
9545    }
9546
9547    fn special_fields(&self) -> &::protobuf::SpecialFields {
9548        &self.special_fields
9549    }
9550
9551    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9552        &mut self.special_fields
9553    }
9554
9555    fn new() -> CancelAuthorization {
9556        CancelAuthorization::new()
9557    }
9558
9559    fn clear(&mut self) {
9560        self.special_fields.clear();
9561    }
9562
9563    fn default_instance() -> &'static CancelAuthorization {
9564        static instance: CancelAuthorization = CancelAuthorization {
9565            special_fields: ::protobuf::SpecialFields::new(),
9566        };
9567        &instance
9568    }
9569}
9570
9571impl ::protobuf::MessageFull for CancelAuthorization {
9572    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9573        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9574        descriptor.get(|| file_descriptor().message_by_package_relative_name("CancelAuthorization").unwrap()).clone()
9575    }
9576}
9577
9578impl ::std::fmt::Display for CancelAuthorization {
9579    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9580        ::protobuf::text_format::fmt(self, f)
9581    }
9582}
9583
9584impl ::protobuf::reflect::ProtobufValue for CancelAuthorization {
9585    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9586}
9587
9588// @@protoc_insertion_point(message:hw.trezor.messages.management.RebootToBootloader)
9589#[derive(PartialEq,Clone,Default,Debug)]
9590pub struct RebootToBootloader {
9591    // message fields
9592    // @@protoc_insertion_point(field:hw.trezor.messages.management.RebootToBootloader.boot_command)
9593    pub boot_command: ::std::option::Option<::protobuf::EnumOrUnknown<reboot_to_bootloader::BootCommand>>,
9594    // @@protoc_insertion_point(field:hw.trezor.messages.management.RebootToBootloader.firmware_header)
9595    pub firmware_header: ::std::option::Option<::std::vec::Vec<u8>>,
9596    // @@protoc_insertion_point(field:hw.trezor.messages.management.RebootToBootloader.language_data_length)
9597    pub language_data_length: ::std::option::Option<u32>,
9598    // special fields
9599    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.RebootToBootloader.special_fields)
9600    pub special_fields: ::protobuf::SpecialFields,
9601}
9602
9603impl<'a> ::std::default::Default for &'a RebootToBootloader {
9604    fn default() -> &'a RebootToBootloader {
9605        <RebootToBootloader as ::protobuf::Message>::default_instance()
9606    }
9607}
9608
9609impl RebootToBootloader {
9610    pub fn new() -> RebootToBootloader {
9611        ::std::default::Default::default()
9612    }
9613
9614    // optional .hw.trezor.messages.management.RebootToBootloader.BootCommand boot_command = 1;
9615
9616    pub fn boot_command(&self) -> reboot_to_bootloader::BootCommand {
9617        match self.boot_command {
9618            Some(e) => e.enum_value_or(reboot_to_bootloader::BootCommand::STOP_AND_WAIT),
9619            None => reboot_to_bootloader::BootCommand::STOP_AND_WAIT,
9620        }
9621    }
9622
9623    pub fn clear_boot_command(&mut self) {
9624        self.boot_command = ::std::option::Option::None;
9625    }
9626
9627    pub fn has_boot_command(&self) -> bool {
9628        self.boot_command.is_some()
9629    }
9630
9631    // Param is passed by value, moved
9632    pub fn set_boot_command(&mut self, v: reboot_to_bootloader::BootCommand) {
9633        self.boot_command = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
9634    }
9635
9636    // optional bytes firmware_header = 2;
9637
9638    pub fn firmware_header(&self) -> &[u8] {
9639        match self.firmware_header.as_ref() {
9640            Some(v) => v,
9641            None => &[],
9642        }
9643    }
9644
9645    pub fn clear_firmware_header(&mut self) {
9646        self.firmware_header = ::std::option::Option::None;
9647    }
9648
9649    pub fn has_firmware_header(&self) -> bool {
9650        self.firmware_header.is_some()
9651    }
9652
9653    // Param is passed by value, moved
9654    pub fn set_firmware_header(&mut self, v: ::std::vec::Vec<u8>) {
9655        self.firmware_header = ::std::option::Option::Some(v);
9656    }
9657
9658    // Mutable pointer to the field.
9659    // If field is not initialized, it is initialized with default value first.
9660    pub fn mut_firmware_header(&mut self) -> &mut ::std::vec::Vec<u8> {
9661        if self.firmware_header.is_none() {
9662            self.firmware_header = ::std::option::Option::Some(::std::vec::Vec::new());
9663        }
9664        self.firmware_header.as_mut().unwrap()
9665    }
9666
9667    // Take field
9668    pub fn take_firmware_header(&mut self) -> ::std::vec::Vec<u8> {
9669        self.firmware_header.take().unwrap_or_else(|| ::std::vec::Vec::new())
9670    }
9671
9672    // optional uint32 language_data_length = 3;
9673
9674    pub fn language_data_length(&self) -> u32 {
9675        self.language_data_length.unwrap_or(0u32)
9676    }
9677
9678    pub fn clear_language_data_length(&mut self) {
9679        self.language_data_length = ::std::option::Option::None;
9680    }
9681
9682    pub fn has_language_data_length(&self) -> bool {
9683        self.language_data_length.is_some()
9684    }
9685
9686    // Param is passed by value, moved
9687    pub fn set_language_data_length(&mut self, v: u32) {
9688        self.language_data_length = ::std::option::Option::Some(v);
9689    }
9690
9691    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9692        let mut fields = ::std::vec::Vec::with_capacity(3);
9693        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9694        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
9695            "boot_command",
9696            |m: &RebootToBootloader| { &m.boot_command },
9697            |m: &mut RebootToBootloader| { &mut m.boot_command },
9698        ));
9699        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
9700            "firmware_header",
9701            |m: &RebootToBootloader| { &m.firmware_header },
9702            |m: &mut RebootToBootloader| { &mut m.firmware_header },
9703        ));
9704        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
9705            "language_data_length",
9706            |m: &RebootToBootloader| { &m.language_data_length },
9707            |m: &mut RebootToBootloader| { &mut m.language_data_length },
9708        ));
9709        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<RebootToBootloader>(
9710            "RebootToBootloader",
9711            fields,
9712            oneofs,
9713        )
9714    }
9715}
9716
9717impl ::protobuf::Message for RebootToBootloader {
9718    const NAME: &'static str = "RebootToBootloader";
9719
9720    fn is_initialized(&self) -> bool {
9721        true
9722    }
9723
9724    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9725        while let Some(tag) = is.read_raw_tag_or_eof()? {
9726            match tag {
9727                8 => {
9728                    self.boot_command = ::std::option::Option::Some(is.read_enum_or_unknown()?);
9729                },
9730                18 => {
9731                    self.firmware_header = ::std::option::Option::Some(is.read_bytes()?);
9732                },
9733                24 => {
9734                    self.language_data_length = ::std::option::Option::Some(is.read_uint32()?);
9735                },
9736                tag => {
9737                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9738                },
9739            };
9740        }
9741        ::std::result::Result::Ok(())
9742    }
9743
9744    // Compute sizes of nested messages
9745    #[allow(unused_variables)]
9746    fn compute_size(&self) -> u64 {
9747        let mut my_size = 0;
9748        if let Some(v) = self.boot_command {
9749            my_size += ::protobuf::rt::int32_size(1, v.value());
9750        }
9751        if let Some(v) = self.firmware_header.as_ref() {
9752            my_size += ::protobuf::rt::bytes_size(2, &v);
9753        }
9754        if let Some(v) = self.language_data_length {
9755            my_size += ::protobuf::rt::uint32_size(3, v);
9756        }
9757        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9758        self.special_fields.cached_size().set(my_size as u32);
9759        my_size
9760    }
9761
9762    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9763        if let Some(v) = self.boot_command {
9764            os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
9765        }
9766        if let Some(v) = self.firmware_header.as_ref() {
9767            os.write_bytes(2, v)?;
9768        }
9769        if let Some(v) = self.language_data_length {
9770            os.write_uint32(3, v)?;
9771        }
9772        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9773        ::std::result::Result::Ok(())
9774    }
9775
9776    fn special_fields(&self) -> &::protobuf::SpecialFields {
9777        &self.special_fields
9778    }
9779
9780    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9781        &mut self.special_fields
9782    }
9783
9784    fn new() -> RebootToBootloader {
9785        RebootToBootloader::new()
9786    }
9787
9788    fn clear(&mut self) {
9789        self.boot_command = ::std::option::Option::None;
9790        self.firmware_header = ::std::option::Option::None;
9791        self.language_data_length = ::std::option::Option::None;
9792        self.special_fields.clear();
9793    }
9794
9795    fn default_instance() -> &'static RebootToBootloader {
9796        static instance: RebootToBootloader = RebootToBootloader {
9797            boot_command: ::std::option::Option::None,
9798            firmware_header: ::std::option::Option::None,
9799            language_data_length: ::std::option::Option::None,
9800            special_fields: ::protobuf::SpecialFields::new(),
9801        };
9802        &instance
9803    }
9804}
9805
9806impl ::protobuf::MessageFull for RebootToBootloader {
9807    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9808        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9809        descriptor.get(|| file_descriptor().message_by_package_relative_name("RebootToBootloader").unwrap()).clone()
9810    }
9811}
9812
9813impl ::std::fmt::Display for RebootToBootloader {
9814    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9815        ::protobuf::text_format::fmt(self, f)
9816    }
9817}
9818
9819impl ::protobuf::reflect::ProtobufValue for RebootToBootloader {
9820    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9821}
9822
9823/// Nested message and enums of message `RebootToBootloader`
9824pub mod reboot_to_bootloader {
9825    #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
9826    // @@protoc_insertion_point(enum:hw.trezor.messages.management.RebootToBootloader.BootCommand)
9827    pub enum BootCommand {
9828        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RebootToBootloader.BootCommand.STOP_AND_WAIT)
9829        STOP_AND_WAIT = 0,
9830        // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RebootToBootloader.BootCommand.INSTALL_UPGRADE)
9831        INSTALL_UPGRADE = 1,
9832    }
9833
9834    impl ::protobuf::Enum for BootCommand {
9835        const NAME: &'static str = "BootCommand";
9836
9837        fn value(&self) -> i32 {
9838            *self as i32
9839        }
9840
9841        fn from_i32(value: i32) -> ::std::option::Option<BootCommand> {
9842            match value {
9843                0 => ::std::option::Option::Some(BootCommand::STOP_AND_WAIT),
9844                1 => ::std::option::Option::Some(BootCommand::INSTALL_UPGRADE),
9845                _ => ::std::option::Option::None
9846            }
9847        }
9848
9849        fn from_str(str: &str) -> ::std::option::Option<BootCommand> {
9850            match str {
9851                "STOP_AND_WAIT" => ::std::option::Option::Some(BootCommand::STOP_AND_WAIT),
9852                "INSTALL_UPGRADE" => ::std::option::Option::Some(BootCommand::INSTALL_UPGRADE),
9853                _ => ::std::option::Option::None
9854            }
9855        }
9856
9857        const VALUES: &'static [BootCommand] = &[
9858            BootCommand::STOP_AND_WAIT,
9859            BootCommand::INSTALL_UPGRADE,
9860        ];
9861    }
9862
9863    impl ::protobuf::EnumFull for BootCommand {
9864        fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
9865            static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
9866            descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("RebootToBootloader.BootCommand").unwrap()).clone()
9867        }
9868
9869        fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
9870            let index = *self as usize;
9871            Self::enum_descriptor().value_by_index(index)
9872        }
9873    }
9874
9875    impl ::std::default::Default for BootCommand {
9876        fn default() -> Self {
9877            BootCommand::STOP_AND_WAIT
9878        }
9879    }
9880
9881    impl BootCommand {
9882        pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
9883            ::protobuf::reflect::GeneratedEnumDescriptorData::new::<BootCommand>("RebootToBootloader.BootCommand")
9884        }
9885    }
9886}
9887
9888// @@protoc_insertion_point(message:hw.trezor.messages.management.GetNonce)
9889#[derive(PartialEq,Clone,Default,Debug)]
9890pub struct GetNonce {
9891    // special fields
9892    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.GetNonce.special_fields)
9893    pub special_fields: ::protobuf::SpecialFields,
9894}
9895
9896impl<'a> ::std::default::Default for &'a GetNonce {
9897    fn default() -> &'a GetNonce {
9898        <GetNonce as ::protobuf::Message>::default_instance()
9899    }
9900}
9901
9902impl GetNonce {
9903    pub fn new() -> GetNonce {
9904        ::std::default::Default::default()
9905    }
9906
9907    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
9908        let mut fields = ::std::vec::Vec::with_capacity(0);
9909        let mut oneofs = ::std::vec::Vec::with_capacity(0);
9910        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<GetNonce>(
9911            "GetNonce",
9912            fields,
9913            oneofs,
9914        )
9915    }
9916}
9917
9918impl ::protobuf::Message for GetNonce {
9919    const NAME: &'static str = "GetNonce";
9920
9921    fn is_initialized(&self) -> bool {
9922        true
9923    }
9924
9925    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
9926        while let Some(tag) = is.read_raw_tag_or_eof()? {
9927            match tag {
9928                tag => {
9929                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
9930                },
9931            };
9932        }
9933        ::std::result::Result::Ok(())
9934    }
9935
9936    // Compute sizes of nested messages
9937    #[allow(unused_variables)]
9938    fn compute_size(&self) -> u64 {
9939        let mut my_size = 0;
9940        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
9941        self.special_fields.cached_size().set(my_size as u32);
9942        my_size
9943    }
9944
9945    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
9946        os.write_unknown_fields(self.special_fields.unknown_fields())?;
9947        ::std::result::Result::Ok(())
9948    }
9949
9950    fn special_fields(&self) -> &::protobuf::SpecialFields {
9951        &self.special_fields
9952    }
9953
9954    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
9955        &mut self.special_fields
9956    }
9957
9958    fn new() -> GetNonce {
9959        GetNonce::new()
9960    }
9961
9962    fn clear(&mut self) {
9963        self.special_fields.clear();
9964    }
9965
9966    fn default_instance() -> &'static GetNonce {
9967        static instance: GetNonce = GetNonce {
9968            special_fields: ::protobuf::SpecialFields::new(),
9969        };
9970        &instance
9971    }
9972}
9973
9974impl ::protobuf::MessageFull for GetNonce {
9975    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
9976        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
9977        descriptor.get(|| file_descriptor().message_by_package_relative_name("GetNonce").unwrap()).clone()
9978    }
9979}
9980
9981impl ::std::fmt::Display for GetNonce {
9982    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
9983        ::protobuf::text_format::fmt(self, f)
9984    }
9985}
9986
9987impl ::protobuf::reflect::ProtobufValue for GetNonce {
9988    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
9989}
9990
9991// @@protoc_insertion_point(message:hw.trezor.messages.management.Nonce)
9992#[derive(PartialEq,Clone,Default,Debug)]
9993pub struct Nonce {
9994    // message fields
9995    // @@protoc_insertion_point(field:hw.trezor.messages.management.Nonce.nonce)
9996    pub nonce: ::std::option::Option<::std::vec::Vec<u8>>,
9997    // special fields
9998    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.Nonce.special_fields)
9999    pub special_fields: ::protobuf::SpecialFields,
10000}
10001
10002impl<'a> ::std::default::Default for &'a Nonce {
10003    fn default() -> &'a Nonce {
10004        <Nonce as ::protobuf::Message>::default_instance()
10005    }
10006}
10007
10008impl Nonce {
10009    pub fn new() -> Nonce {
10010        ::std::default::Default::default()
10011    }
10012
10013    // required bytes nonce = 1;
10014
10015    pub fn nonce(&self) -> &[u8] {
10016        match self.nonce.as_ref() {
10017            Some(v) => v,
10018            None => &[],
10019        }
10020    }
10021
10022    pub fn clear_nonce(&mut self) {
10023        self.nonce = ::std::option::Option::None;
10024    }
10025
10026    pub fn has_nonce(&self) -> bool {
10027        self.nonce.is_some()
10028    }
10029
10030    // Param is passed by value, moved
10031    pub fn set_nonce(&mut self, v: ::std::vec::Vec<u8>) {
10032        self.nonce = ::std::option::Option::Some(v);
10033    }
10034
10035    // Mutable pointer to the field.
10036    // If field is not initialized, it is initialized with default value first.
10037    pub fn mut_nonce(&mut self) -> &mut ::std::vec::Vec<u8> {
10038        if self.nonce.is_none() {
10039            self.nonce = ::std::option::Option::Some(::std::vec::Vec::new());
10040        }
10041        self.nonce.as_mut().unwrap()
10042    }
10043
10044    // Take field
10045    pub fn take_nonce(&mut self) -> ::std::vec::Vec<u8> {
10046        self.nonce.take().unwrap_or_else(|| ::std::vec::Vec::new())
10047    }
10048
10049    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10050        let mut fields = ::std::vec::Vec::with_capacity(1);
10051        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10052        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
10053            "nonce",
10054            |m: &Nonce| { &m.nonce },
10055            |m: &mut Nonce| { &mut m.nonce },
10056        ));
10057        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Nonce>(
10058            "Nonce",
10059            fields,
10060            oneofs,
10061        )
10062    }
10063}
10064
10065impl ::protobuf::Message for Nonce {
10066    const NAME: &'static str = "Nonce";
10067
10068    fn is_initialized(&self) -> bool {
10069        if self.nonce.is_none() {
10070            return false;
10071        }
10072        true
10073    }
10074
10075    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10076        while let Some(tag) = is.read_raw_tag_or_eof()? {
10077            match tag {
10078                10 => {
10079                    self.nonce = ::std::option::Option::Some(is.read_bytes()?);
10080                },
10081                tag => {
10082                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10083                },
10084            };
10085        }
10086        ::std::result::Result::Ok(())
10087    }
10088
10089    // Compute sizes of nested messages
10090    #[allow(unused_variables)]
10091    fn compute_size(&self) -> u64 {
10092        let mut my_size = 0;
10093        if let Some(v) = self.nonce.as_ref() {
10094            my_size += ::protobuf::rt::bytes_size(1, &v);
10095        }
10096        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10097        self.special_fields.cached_size().set(my_size as u32);
10098        my_size
10099    }
10100
10101    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10102        if let Some(v) = self.nonce.as_ref() {
10103            os.write_bytes(1, v)?;
10104        }
10105        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10106        ::std::result::Result::Ok(())
10107    }
10108
10109    fn special_fields(&self) -> &::protobuf::SpecialFields {
10110        &self.special_fields
10111    }
10112
10113    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10114        &mut self.special_fields
10115    }
10116
10117    fn new() -> Nonce {
10118        Nonce::new()
10119    }
10120
10121    fn clear(&mut self) {
10122        self.nonce = ::std::option::Option::None;
10123        self.special_fields.clear();
10124    }
10125
10126    fn default_instance() -> &'static Nonce {
10127        static instance: Nonce = Nonce {
10128            nonce: ::std::option::Option::None,
10129            special_fields: ::protobuf::SpecialFields::new(),
10130        };
10131        &instance
10132    }
10133}
10134
10135impl ::protobuf::MessageFull for Nonce {
10136    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10137        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10138        descriptor.get(|| file_descriptor().message_by_package_relative_name("Nonce").unwrap()).clone()
10139    }
10140}
10141
10142impl ::std::fmt::Display for Nonce {
10143    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10144        ::protobuf::text_format::fmt(self, f)
10145    }
10146}
10147
10148impl ::protobuf::reflect::ProtobufValue for Nonce {
10149    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10150}
10151
10152// @@protoc_insertion_point(message:hw.trezor.messages.management.UnlockPath)
10153#[derive(PartialEq,Clone,Default,Debug)]
10154pub struct UnlockPath {
10155    // message fields
10156    // @@protoc_insertion_point(field:hw.trezor.messages.management.UnlockPath.address_n)
10157    pub address_n: ::std::vec::Vec<u32>,
10158    // @@protoc_insertion_point(field:hw.trezor.messages.management.UnlockPath.mac)
10159    pub mac: ::std::option::Option<::std::vec::Vec<u8>>,
10160    // special fields
10161    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.UnlockPath.special_fields)
10162    pub special_fields: ::protobuf::SpecialFields,
10163}
10164
10165impl<'a> ::std::default::Default for &'a UnlockPath {
10166    fn default() -> &'a UnlockPath {
10167        <UnlockPath as ::protobuf::Message>::default_instance()
10168    }
10169}
10170
10171impl UnlockPath {
10172    pub fn new() -> UnlockPath {
10173        ::std::default::Default::default()
10174    }
10175
10176    // optional bytes mac = 2;
10177
10178    pub fn mac(&self) -> &[u8] {
10179        match self.mac.as_ref() {
10180            Some(v) => v,
10181            None => &[],
10182        }
10183    }
10184
10185    pub fn clear_mac(&mut self) {
10186        self.mac = ::std::option::Option::None;
10187    }
10188
10189    pub fn has_mac(&self) -> bool {
10190        self.mac.is_some()
10191    }
10192
10193    // Param is passed by value, moved
10194    pub fn set_mac(&mut self, v: ::std::vec::Vec<u8>) {
10195        self.mac = ::std::option::Option::Some(v);
10196    }
10197
10198    // Mutable pointer to the field.
10199    // If field is not initialized, it is initialized with default value first.
10200    pub fn mut_mac(&mut self) -> &mut ::std::vec::Vec<u8> {
10201        if self.mac.is_none() {
10202            self.mac = ::std::option::Option::Some(::std::vec::Vec::new());
10203        }
10204        self.mac.as_mut().unwrap()
10205    }
10206
10207    // Take field
10208    pub fn take_mac(&mut self) -> ::std::vec::Vec<u8> {
10209        self.mac.take().unwrap_or_else(|| ::std::vec::Vec::new())
10210    }
10211
10212    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10213        let mut fields = ::std::vec::Vec::with_capacity(2);
10214        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10215        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
10216            "address_n",
10217            |m: &UnlockPath| { &m.address_n },
10218            |m: &mut UnlockPath| { &mut m.address_n },
10219        ));
10220        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
10221            "mac",
10222            |m: &UnlockPath| { &m.mac },
10223            |m: &mut UnlockPath| { &mut m.mac },
10224        ));
10225        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnlockPath>(
10226            "UnlockPath",
10227            fields,
10228            oneofs,
10229        )
10230    }
10231}
10232
10233impl ::protobuf::Message for UnlockPath {
10234    const NAME: &'static str = "UnlockPath";
10235
10236    fn is_initialized(&self) -> bool {
10237        true
10238    }
10239
10240    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10241        while let Some(tag) = is.read_raw_tag_or_eof()? {
10242            match tag {
10243                10 => {
10244                    is.read_repeated_packed_uint32_into(&mut self.address_n)?;
10245                },
10246                8 => {
10247                    self.address_n.push(is.read_uint32()?);
10248                },
10249                18 => {
10250                    self.mac = ::std::option::Option::Some(is.read_bytes()?);
10251                },
10252                tag => {
10253                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10254                },
10255            };
10256        }
10257        ::std::result::Result::Ok(())
10258    }
10259
10260    // Compute sizes of nested messages
10261    #[allow(unused_variables)]
10262    fn compute_size(&self) -> u64 {
10263        let mut my_size = 0;
10264        for value in &self.address_n {
10265            my_size += ::protobuf::rt::uint32_size(1, *value);
10266        };
10267        if let Some(v) = self.mac.as_ref() {
10268            my_size += ::protobuf::rt::bytes_size(2, &v);
10269        }
10270        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10271        self.special_fields.cached_size().set(my_size as u32);
10272        my_size
10273    }
10274
10275    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10276        for v in &self.address_n {
10277            os.write_uint32(1, *v)?;
10278        };
10279        if let Some(v) = self.mac.as_ref() {
10280            os.write_bytes(2, v)?;
10281        }
10282        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10283        ::std::result::Result::Ok(())
10284    }
10285
10286    fn special_fields(&self) -> &::protobuf::SpecialFields {
10287        &self.special_fields
10288    }
10289
10290    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10291        &mut self.special_fields
10292    }
10293
10294    fn new() -> UnlockPath {
10295        UnlockPath::new()
10296    }
10297
10298    fn clear(&mut self) {
10299        self.address_n.clear();
10300        self.mac = ::std::option::Option::None;
10301        self.special_fields.clear();
10302    }
10303
10304    fn default_instance() -> &'static UnlockPath {
10305        static instance: UnlockPath = UnlockPath {
10306            address_n: ::std::vec::Vec::new(),
10307            mac: ::std::option::Option::None,
10308            special_fields: ::protobuf::SpecialFields::new(),
10309        };
10310        &instance
10311    }
10312}
10313
10314impl ::protobuf::MessageFull for UnlockPath {
10315    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10316        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10317        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnlockPath").unwrap()).clone()
10318    }
10319}
10320
10321impl ::std::fmt::Display for UnlockPath {
10322    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10323        ::protobuf::text_format::fmt(self, f)
10324    }
10325}
10326
10327impl ::protobuf::reflect::ProtobufValue for UnlockPath {
10328    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10329}
10330
10331// @@protoc_insertion_point(message:hw.trezor.messages.management.UnlockedPathRequest)
10332#[derive(PartialEq,Clone,Default,Debug)]
10333pub struct UnlockedPathRequest {
10334    // message fields
10335    // @@protoc_insertion_point(field:hw.trezor.messages.management.UnlockedPathRequest.mac)
10336    pub mac: ::std::option::Option<::std::vec::Vec<u8>>,
10337    // special fields
10338    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.UnlockedPathRequest.special_fields)
10339    pub special_fields: ::protobuf::SpecialFields,
10340}
10341
10342impl<'a> ::std::default::Default for &'a UnlockedPathRequest {
10343    fn default() -> &'a UnlockedPathRequest {
10344        <UnlockedPathRequest as ::protobuf::Message>::default_instance()
10345    }
10346}
10347
10348impl UnlockedPathRequest {
10349    pub fn new() -> UnlockedPathRequest {
10350        ::std::default::Default::default()
10351    }
10352
10353    // optional bytes mac = 1;
10354
10355    pub fn mac(&self) -> &[u8] {
10356        match self.mac.as_ref() {
10357            Some(v) => v,
10358            None => &[],
10359        }
10360    }
10361
10362    pub fn clear_mac(&mut self) {
10363        self.mac = ::std::option::Option::None;
10364    }
10365
10366    pub fn has_mac(&self) -> bool {
10367        self.mac.is_some()
10368    }
10369
10370    // Param is passed by value, moved
10371    pub fn set_mac(&mut self, v: ::std::vec::Vec<u8>) {
10372        self.mac = ::std::option::Option::Some(v);
10373    }
10374
10375    // Mutable pointer to the field.
10376    // If field is not initialized, it is initialized with default value first.
10377    pub fn mut_mac(&mut self) -> &mut ::std::vec::Vec<u8> {
10378        if self.mac.is_none() {
10379            self.mac = ::std::option::Option::Some(::std::vec::Vec::new());
10380        }
10381        self.mac.as_mut().unwrap()
10382    }
10383
10384    // Take field
10385    pub fn take_mac(&mut self) -> ::std::vec::Vec<u8> {
10386        self.mac.take().unwrap_or_else(|| ::std::vec::Vec::new())
10387    }
10388
10389    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10390        let mut fields = ::std::vec::Vec::with_capacity(1);
10391        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10392        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
10393            "mac",
10394            |m: &UnlockedPathRequest| { &m.mac },
10395            |m: &mut UnlockedPathRequest| { &mut m.mac },
10396        ));
10397        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnlockedPathRequest>(
10398            "UnlockedPathRequest",
10399            fields,
10400            oneofs,
10401        )
10402    }
10403}
10404
10405impl ::protobuf::Message for UnlockedPathRequest {
10406    const NAME: &'static str = "UnlockedPathRequest";
10407
10408    fn is_initialized(&self) -> bool {
10409        true
10410    }
10411
10412    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10413        while let Some(tag) = is.read_raw_tag_or_eof()? {
10414            match tag {
10415                10 => {
10416                    self.mac = ::std::option::Option::Some(is.read_bytes()?);
10417                },
10418                tag => {
10419                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10420                },
10421            };
10422        }
10423        ::std::result::Result::Ok(())
10424    }
10425
10426    // Compute sizes of nested messages
10427    #[allow(unused_variables)]
10428    fn compute_size(&self) -> u64 {
10429        let mut my_size = 0;
10430        if let Some(v) = self.mac.as_ref() {
10431            my_size += ::protobuf::rt::bytes_size(1, &v);
10432        }
10433        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10434        self.special_fields.cached_size().set(my_size as u32);
10435        my_size
10436    }
10437
10438    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10439        if let Some(v) = self.mac.as_ref() {
10440            os.write_bytes(1, v)?;
10441        }
10442        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10443        ::std::result::Result::Ok(())
10444    }
10445
10446    fn special_fields(&self) -> &::protobuf::SpecialFields {
10447        &self.special_fields
10448    }
10449
10450    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10451        &mut self.special_fields
10452    }
10453
10454    fn new() -> UnlockedPathRequest {
10455        UnlockedPathRequest::new()
10456    }
10457
10458    fn clear(&mut self) {
10459        self.mac = ::std::option::Option::None;
10460        self.special_fields.clear();
10461    }
10462
10463    fn default_instance() -> &'static UnlockedPathRequest {
10464        static instance: UnlockedPathRequest = UnlockedPathRequest {
10465            mac: ::std::option::Option::None,
10466            special_fields: ::protobuf::SpecialFields::new(),
10467        };
10468        &instance
10469    }
10470}
10471
10472impl ::protobuf::MessageFull for UnlockedPathRequest {
10473    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10474        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10475        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnlockedPathRequest").unwrap()).clone()
10476    }
10477}
10478
10479impl ::std::fmt::Display for UnlockedPathRequest {
10480    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10481        ::protobuf::text_format::fmt(self, f)
10482    }
10483}
10484
10485impl ::protobuf::reflect::ProtobufValue for UnlockedPathRequest {
10486    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10487}
10488
10489// @@protoc_insertion_point(message:hw.trezor.messages.management.ShowDeviceTutorial)
10490#[derive(PartialEq,Clone,Default,Debug)]
10491pub struct ShowDeviceTutorial {
10492    // special fields
10493    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.ShowDeviceTutorial.special_fields)
10494    pub special_fields: ::protobuf::SpecialFields,
10495}
10496
10497impl<'a> ::std::default::Default for &'a ShowDeviceTutorial {
10498    fn default() -> &'a ShowDeviceTutorial {
10499        <ShowDeviceTutorial as ::protobuf::Message>::default_instance()
10500    }
10501}
10502
10503impl ShowDeviceTutorial {
10504    pub fn new() -> ShowDeviceTutorial {
10505        ::std::default::Default::default()
10506    }
10507
10508    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10509        let mut fields = ::std::vec::Vec::with_capacity(0);
10510        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10511        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ShowDeviceTutorial>(
10512            "ShowDeviceTutorial",
10513            fields,
10514            oneofs,
10515        )
10516    }
10517}
10518
10519impl ::protobuf::Message for ShowDeviceTutorial {
10520    const NAME: &'static str = "ShowDeviceTutorial";
10521
10522    fn is_initialized(&self) -> bool {
10523        true
10524    }
10525
10526    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10527        while let Some(tag) = is.read_raw_tag_or_eof()? {
10528            match tag {
10529                tag => {
10530                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10531                },
10532            };
10533        }
10534        ::std::result::Result::Ok(())
10535    }
10536
10537    // Compute sizes of nested messages
10538    #[allow(unused_variables)]
10539    fn compute_size(&self) -> u64 {
10540        let mut my_size = 0;
10541        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10542        self.special_fields.cached_size().set(my_size as u32);
10543        my_size
10544    }
10545
10546    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10547        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10548        ::std::result::Result::Ok(())
10549    }
10550
10551    fn special_fields(&self) -> &::protobuf::SpecialFields {
10552        &self.special_fields
10553    }
10554
10555    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10556        &mut self.special_fields
10557    }
10558
10559    fn new() -> ShowDeviceTutorial {
10560        ShowDeviceTutorial::new()
10561    }
10562
10563    fn clear(&mut self) {
10564        self.special_fields.clear();
10565    }
10566
10567    fn default_instance() -> &'static ShowDeviceTutorial {
10568        static instance: ShowDeviceTutorial = ShowDeviceTutorial {
10569            special_fields: ::protobuf::SpecialFields::new(),
10570        };
10571        &instance
10572    }
10573}
10574
10575impl ::protobuf::MessageFull for ShowDeviceTutorial {
10576    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10577        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10578        descriptor.get(|| file_descriptor().message_by_package_relative_name("ShowDeviceTutorial").unwrap()).clone()
10579    }
10580}
10581
10582impl ::std::fmt::Display for ShowDeviceTutorial {
10583    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10584        ::protobuf::text_format::fmt(self, f)
10585    }
10586}
10587
10588impl ::protobuf::reflect::ProtobufValue for ShowDeviceTutorial {
10589    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10590}
10591
10592// @@protoc_insertion_point(message:hw.trezor.messages.management.UnlockBootloader)
10593#[derive(PartialEq,Clone,Default,Debug)]
10594pub struct UnlockBootloader {
10595    // special fields
10596    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.UnlockBootloader.special_fields)
10597    pub special_fields: ::protobuf::SpecialFields,
10598}
10599
10600impl<'a> ::std::default::Default for &'a UnlockBootloader {
10601    fn default() -> &'a UnlockBootloader {
10602        <UnlockBootloader as ::protobuf::Message>::default_instance()
10603    }
10604}
10605
10606impl UnlockBootloader {
10607    pub fn new() -> UnlockBootloader {
10608        ::std::default::Default::default()
10609    }
10610
10611    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10612        let mut fields = ::std::vec::Vec::with_capacity(0);
10613        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10614        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<UnlockBootloader>(
10615            "UnlockBootloader",
10616            fields,
10617            oneofs,
10618        )
10619    }
10620}
10621
10622impl ::protobuf::Message for UnlockBootloader {
10623    const NAME: &'static str = "UnlockBootloader";
10624
10625    fn is_initialized(&self) -> bool {
10626        true
10627    }
10628
10629    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10630        while let Some(tag) = is.read_raw_tag_or_eof()? {
10631            match tag {
10632                tag => {
10633                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10634                },
10635            };
10636        }
10637        ::std::result::Result::Ok(())
10638    }
10639
10640    // Compute sizes of nested messages
10641    #[allow(unused_variables)]
10642    fn compute_size(&self) -> u64 {
10643        let mut my_size = 0;
10644        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10645        self.special_fields.cached_size().set(my_size as u32);
10646        my_size
10647    }
10648
10649    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10650        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10651        ::std::result::Result::Ok(())
10652    }
10653
10654    fn special_fields(&self) -> &::protobuf::SpecialFields {
10655        &self.special_fields
10656    }
10657
10658    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10659        &mut self.special_fields
10660    }
10661
10662    fn new() -> UnlockBootloader {
10663        UnlockBootloader::new()
10664    }
10665
10666    fn clear(&mut self) {
10667        self.special_fields.clear();
10668    }
10669
10670    fn default_instance() -> &'static UnlockBootloader {
10671        static instance: UnlockBootloader = UnlockBootloader {
10672            special_fields: ::protobuf::SpecialFields::new(),
10673        };
10674        &instance
10675    }
10676}
10677
10678impl ::protobuf::MessageFull for UnlockBootloader {
10679    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10680        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10681        descriptor.get(|| file_descriptor().message_by_package_relative_name("UnlockBootloader").unwrap()).clone()
10682    }
10683}
10684
10685impl ::std::fmt::Display for UnlockBootloader {
10686    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10687        ::protobuf::text_format::fmt(self, f)
10688    }
10689}
10690
10691impl ::protobuf::reflect::ProtobufValue for UnlockBootloader {
10692    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10693}
10694
10695// @@protoc_insertion_point(message:hw.trezor.messages.management.SetBrightness)
10696#[derive(PartialEq,Clone,Default,Debug)]
10697pub struct SetBrightness {
10698    // message fields
10699    // @@protoc_insertion_point(field:hw.trezor.messages.management.SetBrightness.value)
10700    pub value: ::std::option::Option<u32>,
10701    // special fields
10702    // @@protoc_insertion_point(special_field:hw.trezor.messages.management.SetBrightness.special_fields)
10703    pub special_fields: ::protobuf::SpecialFields,
10704}
10705
10706impl<'a> ::std::default::Default for &'a SetBrightness {
10707    fn default() -> &'a SetBrightness {
10708        <SetBrightness as ::protobuf::Message>::default_instance()
10709    }
10710}
10711
10712impl SetBrightness {
10713    pub fn new() -> SetBrightness {
10714        ::std::default::Default::default()
10715    }
10716
10717    // optional uint32 value = 1;
10718
10719    pub fn value(&self) -> u32 {
10720        self.value.unwrap_or(0)
10721    }
10722
10723    pub fn clear_value(&mut self) {
10724        self.value = ::std::option::Option::None;
10725    }
10726
10727    pub fn has_value(&self) -> bool {
10728        self.value.is_some()
10729    }
10730
10731    // Param is passed by value, moved
10732    pub fn set_value(&mut self, v: u32) {
10733        self.value = ::std::option::Option::Some(v);
10734    }
10735
10736    fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
10737        let mut fields = ::std::vec::Vec::with_capacity(1);
10738        let mut oneofs = ::std::vec::Vec::with_capacity(0);
10739        fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
10740            "value",
10741            |m: &SetBrightness| { &m.value },
10742            |m: &mut SetBrightness| { &mut m.value },
10743        ));
10744        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<SetBrightness>(
10745            "SetBrightness",
10746            fields,
10747            oneofs,
10748        )
10749    }
10750}
10751
10752impl ::protobuf::Message for SetBrightness {
10753    const NAME: &'static str = "SetBrightness";
10754
10755    fn is_initialized(&self) -> bool {
10756        true
10757    }
10758
10759    fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
10760        while let Some(tag) = is.read_raw_tag_or_eof()? {
10761            match tag {
10762                8 => {
10763                    self.value = ::std::option::Option::Some(is.read_uint32()?);
10764                },
10765                tag => {
10766                    ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
10767                },
10768            };
10769        }
10770        ::std::result::Result::Ok(())
10771    }
10772
10773    // Compute sizes of nested messages
10774    #[allow(unused_variables)]
10775    fn compute_size(&self) -> u64 {
10776        let mut my_size = 0;
10777        if let Some(v) = self.value {
10778            my_size += ::protobuf::rt::uint32_size(1, v);
10779        }
10780        my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
10781        self.special_fields.cached_size().set(my_size as u32);
10782        my_size
10783    }
10784
10785    fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
10786        if let Some(v) = self.value {
10787            os.write_uint32(1, v)?;
10788        }
10789        os.write_unknown_fields(self.special_fields.unknown_fields())?;
10790        ::std::result::Result::Ok(())
10791    }
10792
10793    fn special_fields(&self) -> &::protobuf::SpecialFields {
10794        &self.special_fields
10795    }
10796
10797    fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
10798        &mut self.special_fields
10799    }
10800
10801    fn new() -> SetBrightness {
10802        SetBrightness::new()
10803    }
10804
10805    fn clear(&mut self) {
10806        self.value = ::std::option::Option::None;
10807        self.special_fields.clear();
10808    }
10809
10810    fn default_instance() -> &'static SetBrightness {
10811        static instance: SetBrightness = SetBrightness {
10812            value: ::std::option::Option::None,
10813            special_fields: ::protobuf::SpecialFields::new(),
10814        };
10815        &instance
10816    }
10817}
10818
10819impl ::protobuf::MessageFull for SetBrightness {
10820    fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
10821        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
10822        descriptor.get(|| file_descriptor().message_by_package_relative_name("SetBrightness").unwrap()).clone()
10823    }
10824}
10825
10826impl ::std::fmt::Display for SetBrightness {
10827    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
10828        ::protobuf::text_format::fmt(self, f)
10829    }
10830}
10831
10832impl ::protobuf::reflect::ProtobufValue for SetBrightness {
10833    type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
10834}
10835
10836#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
10837// @@protoc_insertion_point(enum:hw.trezor.messages.management.BackupType)
10838pub enum BackupType {
10839    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Bip39)
10840    Bip39 = 0,
10841    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Slip39_Basic)
10842    Slip39_Basic = 1,
10843    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Slip39_Advanced)
10844    Slip39_Advanced = 2,
10845    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Slip39_Single_Extendable)
10846    Slip39_Single_Extendable = 3,
10847    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Slip39_Basic_Extendable)
10848    Slip39_Basic_Extendable = 4,
10849    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.BackupType.Slip39_Advanced_Extendable)
10850    Slip39_Advanced_Extendable = 5,
10851}
10852
10853impl ::protobuf::Enum for BackupType {
10854    const NAME: &'static str = "BackupType";
10855
10856    fn value(&self) -> i32 {
10857        *self as i32
10858    }
10859
10860    fn from_i32(value: i32) -> ::std::option::Option<BackupType> {
10861        match value {
10862            0 => ::std::option::Option::Some(BackupType::Bip39),
10863            1 => ::std::option::Option::Some(BackupType::Slip39_Basic),
10864            2 => ::std::option::Option::Some(BackupType::Slip39_Advanced),
10865            3 => ::std::option::Option::Some(BackupType::Slip39_Single_Extendable),
10866            4 => ::std::option::Option::Some(BackupType::Slip39_Basic_Extendable),
10867            5 => ::std::option::Option::Some(BackupType::Slip39_Advanced_Extendable),
10868            _ => ::std::option::Option::None
10869        }
10870    }
10871
10872    fn from_str(str: &str) -> ::std::option::Option<BackupType> {
10873        match str {
10874            "Bip39" => ::std::option::Option::Some(BackupType::Bip39),
10875            "Slip39_Basic" => ::std::option::Option::Some(BackupType::Slip39_Basic),
10876            "Slip39_Advanced" => ::std::option::Option::Some(BackupType::Slip39_Advanced),
10877            "Slip39_Single_Extendable" => ::std::option::Option::Some(BackupType::Slip39_Single_Extendable),
10878            "Slip39_Basic_Extendable" => ::std::option::Option::Some(BackupType::Slip39_Basic_Extendable),
10879            "Slip39_Advanced_Extendable" => ::std::option::Option::Some(BackupType::Slip39_Advanced_Extendable),
10880            _ => ::std::option::Option::None
10881        }
10882    }
10883
10884    const VALUES: &'static [BackupType] = &[
10885        BackupType::Bip39,
10886        BackupType::Slip39_Basic,
10887        BackupType::Slip39_Advanced,
10888        BackupType::Slip39_Single_Extendable,
10889        BackupType::Slip39_Basic_Extendable,
10890        BackupType::Slip39_Advanced_Extendable,
10891    ];
10892}
10893
10894impl ::protobuf::EnumFull for BackupType {
10895    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
10896        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
10897        descriptor.get(|| file_descriptor().enum_by_package_relative_name("BackupType").unwrap()).clone()
10898    }
10899
10900    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
10901        let index = *self as usize;
10902        Self::enum_descriptor().value_by_index(index)
10903    }
10904}
10905
10906impl ::std::default::Default for BackupType {
10907    fn default() -> Self {
10908        BackupType::Bip39
10909    }
10910}
10911
10912impl BackupType {
10913    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
10914        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<BackupType>("BackupType")
10915    }
10916}
10917
10918#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
10919// @@protoc_insertion_point(enum:hw.trezor.messages.management.SafetyCheckLevel)
10920pub enum SafetyCheckLevel {
10921    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SafetyCheckLevel.Strict)
10922    Strict = 0,
10923    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SafetyCheckLevel.PromptAlways)
10924    PromptAlways = 1,
10925    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.SafetyCheckLevel.PromptTemporarily)
10926    PromptTemporarily = 2,
10927}
10928
10929impl ::protobuf::Enum for SafetyCheckLevel {
10930    const NAME: &'static str = "SafetyCheckLevel";
10931
10932    fn value(&self) -> i32 {
10933        *self as i32
10934    }
10935
10936    fn from_i32(value: i32) -> ::std::option::Option<SafetyCheckLevel> {
10937        match value {
10938            0 => ::std::option::Option::Some(SafetyCheckLevel::Strict),
10939            1 => ::std::option::Option::Some(SafetyCheckLevel::PromptAlways),
10940            2 => ::std::option::Option::Some(SafetyCheckLevel::PromptTemporarily),
10941            _ => ::std::option::Option::None
10942        }
10943    }
10944
10945    fn from_str(str: &str) -> ::std::option::Option<SafetyCheckLevel> {
10946        match str {
10947            "Strict" => ::std::option::Option::Some(SafetyCheckLevel::Strict),
10948            "PromptAlways" => ::std::option::Option::Some(SafetyCheckLevel::PromptAlways),
10949            "PromptTemporarily" => ::std::option::Option::Some(SafetyCheckLevel::PromptTemporarily),
10950            _ => ::std::option::Option::None
10951        }
10952    }
10953
10954    const VALUES: &'static [SafetyCheckLevel] = &[
10955        SafetyCheckLevel::Strict,
10956        SafetyCheckLevel::PromptAlways,
10957        SafetyCheckLevel::PromptTemporarily,
10958    ];
10959}
10960
10961impl ::protobuf::EnumFull for SafetyCheckLevel {
10962    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
10963        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
10964        descriptor.get(|| file_descriptor().enum_by_package_relative_name("SafetyCheckLevel").unwrap()).clone()
10965    }
10966
10967    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
10968        let index = *self as usize;
10969        Self::enum_descriptor().value_by_index(index)
10970    }
10971}
10972
10973impl ::std::default::Default for SafetyCheckLevel {
10974    fn default() -> Self {
10975        SafetyCheckLevel::Strict
10976    }
10977}
10978
10979impl SafetyCheckLevel {
10980    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
10981        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<SafetyCheckLevel>("SafetyCheckLevel")
10982    }
10983}
10984
10985#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
10986// @@protoc_insertion_point(enum:hw.trezor.messages.management.HomescreenFormat)
10987pub enum HomescreenFormat {
10988    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.HomescreenFormat.Toif)
10989    Toif = 1,
10990    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.HomescreenFormat.Jpeg)
10991    Jpeg = 2,
10992    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.HomescreenFormat.ToiG)
10993    ToiG = 3,
10994}
10995
10996impl ::protobuf::Enum for HomescreenFormat {
10997    const NAME: &'static str = "HomescreenFormat";
10998
10999    fn value(&self) -> i32 {
11000        *self as i32
11001    }
11002
11003    fn from_i32(value: i32) -> ::std::option::Option<HomescreenFormat> {
11004        match value {
11005            1 => ::std::option::Option::Some(HomescreenFormat::Toif),
11006            2 => ::std::option::Option::Some(HomescreenFormat::Jpeg),
11007            3 => ::std::option::Option::Some(HomescreenFormat::ToiG),
11008            _ => ::std::option::Option::None
11009        }
11010    }
11011
11012    fn from_str(str: &str) -> ::std::option::Option<HomescreenFormat> {
11013        match str {
11014            "Toif" => ::std::option::Option::Some(HomescreenFormat::Toif),
11015            "Jpeg" => ::std::option::Option::Some(HomescreenFormat::Jpeg),
11016            "ToiG" => ::std::option::Option::Some(HomescreenFormat::ToiG),
11017            _ => ::std::option::Option::None
11018        }
11019    }
11020
11021    const VALUES: &'static [HomescreenFormat] = &[
11022        HomescreenFormat::Toif,
11023        HomescreenFormat::Jpeg,
11024        HomescreenFormat::ToiG,
11025    ];
11026}
11027
11028impl ::protobuf::EnumFull for HomescreenFormat {
11029    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
11030        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
11031        descriptor.get(|| file_descriptor().enum_by_package_relative_name("HomescreenFormat").unwrap()).clone()
11032    }
11033
11034    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
11035        let index = match self {
11036            HomescreenFormat::Toif => 0,
11037            HomescreenFormat::Jpeg => 1,
11038            HomescreenFormat::ToiG => 2,
11039        };
11040        Self::enum_descriptor().value_by_index(index)
11041    }
11042}
11043
11044// Note, `Default` is implemented although default value is not 0
11045impl ::std::default::Default for HomescreenFormat {
11046    fn default() -> Self {
11047        HomescreenFormat::Toif
11048    }
11049}
11050
11051impl HomescreenFormat {
11052    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
11053        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<HomescreenFormat>("HomescreenFormat")
11054    }
11055}
11056
11057#[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
11058// @@protoc_insertion_point(enum:hw.trezor.messages.management.RecoveryType)
11059pub enum RecoveryType {
11060    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RecoveryType.NormalRecovery)
11061    NormalRecovery = 0,
11062    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RecoveryType.DryRun)
11063    DryRun = 1,
11064    // @@protoc_insertion_point(enum_value:hw.trezor.messages.management.RecoveryType.UnlockRepeatedBackup)
11065    UnlockRepeatedBackup = 2,
11066}
11067
11068impl ::protobuf::Enum for RecoveryType {
11069    const NAME: &'static str = "RecoveryType";
11070
11071    fn value(&self) -> i32 {
11072        *self as i32
11073    }
11074
11075    fn from_i32(value: i32) -> ::std::option::Option<RecoveryType> {
11076        match value {
11077            0 => ::std::option::Option::Some(RecoveryType::NormalRecovery),
11078            1 => ::std::option::Option::Some(RecoveryType::DryRun),
11079            2 => ::std::option::Option::Some(RecoveryType::UnlockRepeatedBackup),
11080            _ => ::std::option::Option::None
11081        }
11082    }
11083
11084    fn from_str(str: &str) -> ::std::option::Option<RecoveryType> {
11085        match str {
11086            "NormalRecovery" => ::std::option::Option::Some(RecoveryType::NormalRecovery),
11087            "DryRun" => ::std::option::Option::Some(RecoveryType::DryRun),
11088            "UnlockRepeatedBackup" => ::std::option::Option::Some(RecoveryType::UnlockRepeatedBackup),
11089            _ => ::std::option::Option::None
11090        }
11091    }
11092
11093    const VALUES: &'static [RecoveryType] = &[
11094        RecoveryType::NormalRecovery,
11095        RecoveryType::DryRun,
11096        RecoveryType::UnlockRepeatedBackup,
11097    ];
11098}
11099
11100impl ::protobuf::EnumFull for RecoveryType {
11101    fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
11102        static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
11103        descriptor.get(|| file_descriptor().enum_by_package_relative_name("RecoveryType").unwrap()).clone()
11104    }
11105
11106    fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
11107        let index = *self as usize;
11108        Self::enum_descriptor().value_by_index(index)
11109    }
11110}
11111
11112impl ::std::default::Default for RecoveryType {
11113    fn default() -> Self {
11114        RecoveryType::NormalRecovery
11115    }
11116}
11117
11118impl RecoveryType {
11119    fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
11120        ::protobuf::reflect::GeneratedEnumDescriptorData::new::<RecoveryType>("RecoveryType")
11121    }
11122}
11123
11124static file_descriptor_proto_data: &'static [u8] = b"\
11125    \n\x19messages-management.proto\x12\x1dhw.trezor.messages.management\x1a\
11126    \x0emessages.proto\"\x80\x01\n\nInitialize\x12\x1d\n\nsession_id\x18\x01\
11127    \x20\x01(\x0cR\tsessionId\x12,\n\x10_skip_passphrase\x18\x02\x20\x01(\
11128    \x08R\x0eSkipPassphraseB\x02\x18\x01\x12%\n\x0ederive_cardano\x18\x03\
11129    \x20\x01(\x08R\rderiveCardano\"\r\n\x0bGetFeatures\"\xd6\x17\n\x08Featur\
11130    es\x12\x16\n\x06vendor\x18\x01\x20\x01(\tR\x06vendor\x12#\n\rmajor_versi\
11131    on\x18\x02\x20\x02(\rR\x0cmajorVersion\x12#\n\rminor_version\x18\x03\x20\
11132    \x02(\rR\x0cminorVersion\x12#\n\rpatch_version\x18\x04\x20\x02(\rR\x0cpa\
11133    tchVersion\x12'\n\x0fbootloader_mode\x18\x05\x20\x01(\x08R\x0ebootloader\
11134    Mode\x12\x1b\n\tdevice_id\x18\x06\x20\x01(\tR\x08deviceId\x12%\n\x0epin_\
11135    protection\x18\x07\x20\x01(\x08R\rpinProtection\x123\n\x15passphrase_pro\
11136    tection\x18\x08\x20\x01(\x08R\x14passphraseProtection\x12\x1a\n\x08langu\
11137    age\x18\t\x20\x01(\tR\x08language\x12\x14\n\x05label\x18\n\x20\x01(\tR\
11138    \x05label\x12\x20\n\x0binitialized\x18\x0c\x20\x01(\x08R\x0binitialized\
11139    \x12\x1a\n\x08revision\x18\r\x20\x01(\x0cR\x08revision\x12'\n\x0fbootloa\
11140    der_hash\x18\x0e\x20\x01(\x0cR\x0ebootloaderHash\x12\x1a\n\x08imported\
11141    \x18\x0f\x20\x01(\x08R\x08imported\x12\x1a\n\x08unlocked\x18\x10\x20\x01\
11142    (\x08R\x08unlocked\x120\n\x12_passphrase_cached\x18\x11\x20\x01(\x08R\
11143    \x10PassphraseCachedB\x02\x18\x01\x12)\n\x10firmware_present\x18\x12\x20\
11144    \x01(\x08R\x0ffirmwarePresent\x12k\n\x13backup_availability\x18\x13\x20\
11145    \x01(\x0e2:.hw.trezor.messages.management.Features.BackupAvailabilityR\
11146    \x12backupAvailability\x12\x14\n\x05flags\x18\x14\x20\x01(\rR\x05flags\
11147    \x12\x14\n\x05model\x18\x15\x20\x01(\tR\x05model\x12\x19\n\x08fw_major\
11148    \x18\x16\x20\x01(\rR\x07fwMajor\x12\x19\n\x08fw_minor\x18\x17\x20\x01(\r\
11149    R\x07fwMinor\x12\x19\n\x08fw_patch\x18\x18\x20\x01(\rR\x07fwPatch\x12\
11150    \x1b\n\tfw_vendor\x18\x19\x20\x01(\tR\x08fwVendor\x12+\n\x11unfinished_b\
11151    ackup\x18\x1b\x20\x01(\x08R\x10unfinishedBackup\x12\x1b\n\tno_backup\x18\
11152    \x1c\x20\x01(\x08R\x08noBackup\x12_\n\x0frecovery_status\x18\x1d\x20\x01\
11153    (\x0e26.hw.trezor.messages.management.Features.RecoveryStatusR\x0erecove\
11154    ryStatus\x12V\n\x0ccapabilities\x18\x1e\x20\x03(\x0e22.hw.trezor.message\
11155    s.management.Features.CapabilityR\x0ccapabilities\x12J\n\x0bbackup_type\
11156    \x18\x1f\x20\x01(\x0e2).hw.trezor.messages.management.BackupTypeR\nbacku\
11157    pType\x12&\n\x0fsd_card_present\x18\x20\x20\x01(\x08R\rsdCardPresent\x12\
11158    #\n\rsd_protection\x18!\x20\x01(\x08R\x0csdProtection\x120\n\x14wipe_cod\
11159    e_protection\x18\"\x20\x01(\x08R\x12wipeCodeProtection\x12\x1d\n\nsessio\
11160    n_id\x18#\x20\x01(\x0cR\tsessionId\x12=\n\x1bpassphrase_always_on_device\
11161    \x18$\x20\x01(\x08R\x18passphraseAlwaysOnDevice\x12T\n\rsafety_checks\
11162    \x18%\x20\x01(\x0e2/.hw.trezor.messages.management.SafetyCheckLevelR\x0c\
11163    safetyChecks\x12+\n\x12auto_lock_delay_ms\x18&\x20\x01(\rR\x0fautoLockDe\
11164    layMs\x12)\n\x10display_rotation\x18'\x20\x01(\rR\x0fdisplayRotation\x12\
11165    3\n\x15experimental_features\x18(\x20\x01(\x08R\x14experimentalFeatures\
11166    \x12\x12\n\x04busy\x18)\x20\x01(\x08R\x04busy\x12\\\n\x11homescreen_form\
11167    at\x18*\x20\x01(\x0e2/.hw.trezor.messages.management.HomescreenFormatR\
11168    \x10homescreenFormat\x129\n\x19hide_passphrase_from_host\x18+\x20\x01(\
11169    \x08R\x16hidePassphraseFromHost\x12%\n\x0einternal_model\x18,\x20\x01(\t\
11170    R\rinternalModel\x12\x1d\n\nunit_color\x18-\x20\x01(\rR\tunitColor\x12!\
11171    \n\x0cunit_btconly\x18.\x20\x01(\x08R\x0bunitBtconly\x12)\n\x10homescree\
11172    n_width\x18/\x20\x01(\rR\x0fhomescreenWidth\x12+\n\x11homescreen_height\
11173    \x180\x20\x01(\rR\x10homescreenHeight\x12+\n\x11bootloader_locked\x181\
11174    \x20\x01(\x08R\x10bootloaderLocked\x12>\n\x18language_version_matches\
11175    \x182\x20\x01(\x08:\x04trueR\x16languageVersionMatches\x12%\n\x0eunit_pa\
11176    ckaging\x183\x20\x01(\rR\runitPackaging\x12'\n\x0fhaptic_feedback\x184\
11177    \x20\x01(\x08R\x0ehapticFeedback\x12P\n\rrecovery_type\x185\x20\x01(\x0e\
11178    2+.hw.trezor.messages.management.RecoveryTypeR\x0crecoveryType\x12\x1d\n\
11179    \noptiga_sec\x186\x20\x01(\rR\toptigaSec\"C\n\x12BackupAvailability\x12\
11180    \x10\n\x0cNotAvailable\x10\0\x12\x0c\n\x08Required\x10\x01\x12\r\n\tAvai\
11181    lable\x10\x02\"7\n\x0eRecoveryStatus\x12\x0b\n\x07Nothing\x10\0\x12\x0c\
11182    \n\x08Recovery\x10\x01\x12\n\n\x06Backup\x10\x02\"\xc2\x04\n\nCapability\
11183    \x12\x1c\n\x12Capability_Bitcoin\x10\x01\x1a\x04\x80\xa6\x1d\x01\x12\x1b\
11184    \n\x17Capability_Bitcoin_like\x10\x02\x12\x16\n\x12Capability_Binance\
11185    \x10\x03\x12\x16\n\x12Capability_Cardano\x10\x04\x12\x1b\n\x11Capability\
11186    _Crypto\x10\x05\x1a\x04\x80\xa6\x1d\x01\x12\x12\n\x0eCapability_EOS\x10\
11187    \x06\x12\x17\n\x13Capability_Ethereum\x10\x07\x12\x17\n\x0fCapability_Li\
11188    sk\x10\x08\x1a\x02\x08\x01\x12\x15\n\x11Capability_Monero\x10\t\x12\x12\
11189    \n\x0eCapability_NEM\x10\n\x12\x15\n\x11Capability_Ripple\x10\x0b\x12\
11190    \x16\n\x12Capability_Stellar\x10\x0c\x12\x14\n\x10Capability_Tezos\x10\r\
11191    \x12\x12\n\x0eCapability_U2F\x10\x0e\x12\x1b\n\x11Capability_Shamir\x10\
11192    \x0f\x1a\x04\x80\xa6\x1d\x01\x12!\n\x17Capability_ShamirGroups\x10\x10\
11193    \x1a\x04\x80\xa6\x1d\x01\x12$\n\x1aCapability_PassphraseEntry\x10\x11\
11194    \x1a\x04\x80\xa6\x1d\x01\x12\x15\n\x11Capability_Solana\x10\x12\x12!\n\
11195    \x17Capability_Translations\x10\x13\x1a\x04\x80\xa6\x1d\x01\x12\x1f\n\
11196    \x15Capability_Brightness\x10\x14\x1a\x04\x80\xa6\x1d\x01\x12\x1b\n\x11C\
11197    apability_Haptic\x10\x15\x1a\x04\x80\xa6\x1d\x01\x1a\x04\xc8\xf3\x18\x01\
11198    \"\x0c\n\nLockDevice\"&\n\x07SetBusy\x12\x1b\n\texpiry_ms\x18\x01\x20\
11199    \x01(\rR\x08expiryMs\"\x0c\n\nEndSession\"\xc4\x04\n\rApplySettings\x12\
11200    \x1e\n\x08language\x18\x01\x20\x01(\tR\x08languageB\x02\x18\x01\x12\x14\
11201    \n\x05label\x18\x02\x20\x01(\tR\x05label\x12%\n\x0euse_passphrase\x18\
11202    \x03\x20\x01(\x08R\rusePassphrase\x12\x1e\n\nhomescreen\x18\x04\x20\x01(\
11203    \x0cR\nhomescreen\x120\n\x12_passphrase_source\x18\x05\x20\x01(\rR\x10Pa\
11204    ssphraseSourceB\x02\x18\x01\x12+\n\x12auto_lock_delay_ms\x18\x06\x20\x01\
11205    (\rR\x0fautoLockDelayMs\x12)\n\x10display_rotation\x18\x07\x20\x01(\rR\
11206    \x0fdisplayRotation\x12=\n\x1bpassphrase_always_on_device\x18\x08\x20\
11207    \x01(\x08R\x18passphraseAlwaysOnDevice\x12T\n\rsafety_checks\x18\t\x20\
11208    \x01(\x0e2/.hw.trezor.messages.management.SafetyCheckLevelR\x0csafetyChe\
11209    cks\x123\n\x15experimental_features\x18\n\x20\x01(\x08R\x14experimentalF\
11210    eatures\x129\n\x19hide_passphrase_from_host\x18\x0b\x20\x01(\x08R\x16hid\
11211    ePassphraseFromHost\x12'\n\x0fhaptic_feedback\x18\r\x20\x01(\x08R\x0ehap\
11212    ticFeedback\"T\n\x0eChangeLanguage\x12\x1f\n\x0bdata_length\x18\x01\x20\
11213    \x02(\rR\ndataLength\x12!\n\x0cshow_display\x18\x02\x20\x01(\x08R\x0bsho\
11214    wDisplay\"Z\n\x16TranslationDataRequest\x12\x1f\n\x0bdata_length\x18\x01\
11215    \x20\x02(\rR\ndataLength\x12\x1f\n\x0bdata_offset\x18\x02\x20\x02(\rR\nd\
11216    ataOffset\"3\n\x12TranslationDataAck\x12\x1d\n\ndata_chunk\x18\x01\x20\
11217    \x02(\x0cR\tdataChunk\"\"\n\nApplyFlags\x12\x14\n\x05flags\x18\x01\x20\
11218    \x02(\rR\x05flags\"#\n\tChangePin\x12\x16\n\x06remove\x18\x01\x20\x01(\
11219    \x08R\x06remove\"(\n\x0eChangeWipeCode\x12\x16\n\x06remove\x18\x01\x20\
11220    \x01(\x08R\x06remove\"\xaa\x01\n\tSdProtect\x12]\n\toperation\x18\x01\
11221    \x20\x02(\x0e2?.hw.trezor.messages.management.SdProtect.SdProtectOperati\
11222    onTypeR\toperation\">\n\x16SdProtectOperationType\x12\x0b\n\x07DISABLE\
11223    \x10\0\x12\n\n\x06ENABLE\x10\x01\x12\x0b\n\x07REFRESH\x10\x02\"O\n\x04Pi\
11224    ng\x12\x1a\n\x07message\x18\x01\x20\x01(\t:\0R\x07message\x12+\n\x11butt\
11225    on_protection\x18\x02\x20\x01(\x08R\x10buttonProtection\"\x08\n\x06Cance\
11226    l\"\x20\n\nGetEntropy\x12\x12\n\x04size\x18\x01\x20\x02(\rR\x04size\"#\n\
11227    \x07Entropy\x12\x18\n\x07entropy\x18\x01\x20\x02(\x0cR\x07entropy\"/\n\
11228    \x0fGetFirmwareHash\x12\x1c\n\tchallenge\x18\x01\x20\x01(\x0cR\tchalleng\
11229    e\"\"\n\x0cFirmwareHash\x12\x12\n\x04hash\x18\x01\x20\x02(\x0cR\x04hash\
11230    \"2\n\x12AuthenticateDevice\x12\x1c\n\tchallenge\x18\x01\x20\x02(\x0cR\t\
11231    challenge\"U\n\x11AuthenticityProof\x12\"\n\x0ccertificates\x18\x01\x20\
11232    \x03(\x0cR\x0ccertificates\x12\x1c\n\tsignature\x18\x02\x20\x02(\x0cR\ts\
11233    ignature\"\x0c\n\nWipeDevice\"\xad\x02\n\nLoadDevice\x12\x1c\n\tmnemonic\
11234    s\x18\x01\x20\x03(\tR\tmnemonics\x12\x10\n\x03pin\x18\x03\x20\x01(\tR\
11235    \x03pin\x123\n\x15passphrase_protection\x18\x04\x20\x01(\x08R\x14passphr\
11236    aseProtection\x12\x1e\n\x08language\x18\x05\x20\x01(\tR\x08languageB\x02\
11237    \x18\x01\x12\x14\n\x05label\x18\x06\x20\x01(\tR\x05label\x12#\n\rskip_ch\
11238    ecksum\x18\x07\x20\x01(\x08R\x0cskipChecksum\x12\x1f\n\x0bu2f_counter\
11239    \x18\x08\x20\x01(\rR\nu2fCounter\x12!\n\x0cneeds_backup\x18\t\x20\x01(\
11240    \x08R\x0bneedsBackup\x12\x1b\n\tno_backup\x18\n\x20\x01(\x08R\x08noBacku\
11241    p\"\x99\x03\n\x0bResetDevice\x12%\n\x0edisplay_random\x18\x01\x20\x01(\
11242    \x08R\rdisplayRandom\x12\x1f\n\x08strength\x18\x02\x20\x01(\r:\x03256R\
11243    \x08strength\x123\n\x15passphrase_protection\x18\x03\x20\x01(\x08R\x14pa\
11244    ssphraseProtection\x12%\n\x0epin_protection\x18\x04\x20\x01(\x08R\rpinPr\
11245    otection\x12\x1e\n\x08language\x18\x05\x20\x01(\tR\x08languageB\x02\x18\
11246    \x01\x12\x14\n\x05label\x18\x06\x20\x01(\tR\x05label\x12\x1f\n\x0bu2f_co\
11247    unter\x18\x07\x20\x01(\rR\nu2fCounter\x12\x1f\n\x0bskip_backup\x18\x08\
11248    \x20\x01(\x08R\nskipBackup\x12\x1b\n\tno_backup\x18\t\x20\x01(\x08R\x08n\
11249    oBackup\x12Q\n\x0bbackup_type\x18\n\x20\x01(\x0e2).hw.trezor.messages.ma\
11250    nagement.BackupType:\x05Bip39R\nbackupType\"\xe5\x01\n\x0cBackupDevice\
11251    \x12'\n\x0fgroup_threshold\x18\x01\x20\x01(\rR\x0egroupThreshold\x12O\n\
11252    \x06groups\x18\x02\x20\x03(\x0b27.hw.trezor.messages.management.BackupDe\
11253    vice.Slip39GroupR\x06groups\x1a[\n\x0bSlip39Group\x12)\n\x10member_thres\
11254    hold\x18\x01\x20\x02(\rR\x0fmemberThreshold\x12!\n\x0cmember_count\x18\
11255    \x02\x20\x02(\rR\x0bmemberCount\"\x10\n\x0eEntropyRequest\"&\n\nEntropyA\
11256    ck\x12\x18\n\x07entropy\x18\x01\x20\x02(\x0cR\x07entropy\"\x8d\x04\n\x0e\
11257    RecoveryDevice\x12\x1d\n\nword_count\x18\x01\x20\x01(\rR\twordCount\x123\
11258    \n\x15passphrase_protection\x18\x02\x20\x01(\x08R\x14passphraseProtectio\
11259    n\x12%\n\x0epin_protection\x18\x03\x20\x01(\x08R\rpinProtection\x12\x1e\
11260    \n\x08language\x18\x04\x20\x01(\tR\x08languageB\x02\x18\x01\x12\x14\n\
11261    \x05label\x18\x05\x20\x01(\tR\x05label\x12)\n\x10enforce_wordlist\x18\
11262    \x06\x20\x01(\x08R\x0fenforceWordlist\x12j\n\x0cinput_method\x18\x08\x20\
11263    \x01(\x0e2G.hw.trezor.messages.management.RecoveryDevice.RecoveryDeviceI\
11264    nputMethodR\x0binputMethod\x12\x1f\n\x0bu2f_counter\x18\t\x20\x01(\rR\nu\
11265    2fCounter\x12O\n\x04type\x18\n\x20\x01(\x0e2+.hw.trezor.messages.managem\
11266    ent.RecoveryType:\x0eNormalRecoveryR\x04type\";\n\x19RecoveryDeviceInput\
11267    Method\x12\x12\n\x0eScrambledWords\x10\0\x12\n\n\x06Matrix\x10\x01J\x04\
11268    \x08\x07\x10\x08\"\xc5\x01\n\x0bWordRequest\x12N\n\x04type\x18\x01\x20\
11269    \x02(\x0e2:.hw.trezor.messages.management.WordRequest.WordRequestTypeR\
11270    \x04type\"f\n\x0fWordRequestType\x12\x19\n\x15WordRequestType_Plain\x10\
11271    \0\x12\x1b\n\x17WordRequestType_Matrix9\x10\x01\x12\x1b\n\x17WordRequest\
11272    Type_Matrix6\x10\x02\"\x1d\n\x07WordAck\x12\x12\n\x04word\x18\x01\x20\
11273    \x02(\tR\x04word\"0\n\rSetU2FCounter\x12\x1f\n\x0bu2f_counter\x18\x01\
11274    \x20\x02(\rR\nu2fCounter\"\x13\n\x11GetNextU2FCounter\"1\n\x0eNextU2FCou\
11275    nter\x12\x1f\n\x0bu2f_counter\x18\x01\x20\x02(\rR\nu2fCounter\"\x11\n\
11276    \x0fDoPreauthorized\"\x16\n\x14PreauthorizedRequest\"\x15\n\x13CancelAut\
11277    horization\"\x9a\x02\n\x12RebootToBootloader\x12o\n\x0cboot_command\x18\
11278    \x01\x20\x01(\x0e2=.hw.trezor.messages.management.RebootToBootloader.Boo\
11279    tCommand:\rSTOP_AND_WAITR\x0bbootCommand\x12'\n\x0ffirmware_header\x18\
11280    \x02\x20\x01(\x0cR\x0efirmwareHeader\x123\n\x14language_data_length\x18\
11281    \x03\x20\x01(\r:\x010R\x12languageDataLength\"5\n\x0bBootCommand\x12\x11\
11282    \n\rSTOP_AND_WAIT\x10\0\x12\x13\n\x0fINSTALL_UPGRADE\x10\x01\"\x10\n\x08\
11283    GetNonce:\x04\x88\xb2\x19\x01\"#\n\x05Nonce\x12\x14\n\x05nonce\x18\x01\
11284    \x20\x02(\x0cR\x05nonce:\x04\x88\xb2\x19\x01\";\n\nUnlockPath\x12\x1b\n\
11285    \taddress_n\x18\x01\x20\x03(\rR\x08addressN\x12\x10\n\x03mac\x18\x02\x20\
11286    \x01(\x0cR\x03mac\"'\n\x13UnlockedPathRequest\x12\x10\n\x03mac\x18\x01\
11287    \x20\x01(\x0cR\x03mac\"\x14\n\x12ShowDeviceTutorial\"\x12\n\x10UnlockBoo\
11288    tloader\"%\n\rSetBrightness\x12\x14\n\x05value\x18\x01\x20\x01(\rR\x05va\
11289    lue*\x99\x01\n\nBackupType\x12\t\n\x05Bip39\x10\0\x12\x10\n\x0cSlip39_Ba\
11290    sic\x10\x01\x12\x13\n\x0fSlip39_Advanced\x10\x02\x12\x1c\n\x18Slip39_Sin\
11291    gle_Extendable\x10\x03\x12\x1b\n\x17Slip39_Basic_Extendable\x10\x04\x12\
11292    \x1e\n\x1aSlip39_Advanced_Extendable\x10\x05*G\n\x10SafetyCheckLevel\x12\
11293    \n\n\x06Strict\x10\0\x12\x10\n\x0cPromptAlways\x10\x01\x12\x15\n\x11Prom\
11294    ptTemporarily\x10\x02*0\n\x10HomescreenFormat\x12\x08\n\x04Toif\x10\x01\
11295    \x12\x08\n\x04Jpeg\x10\x02\x12\x08\n\x04ToiG\x10\x03*H\n\x0cRecoveryType\
11296    \x12\x12\n\x0eNormalRecovery\x10\0\x12\n\n\x06DryRun\x10\x01\x12\x18\n\
11297    \x14UnlockRepeatedBackup\x10\x02BB\n#com.satoshilabs.trezor.lib.protobuf\
11298    B\x17TrezorMessageManagement\x80\xa6\x1d\x01\
11299";
11300
11301/// `FileDescriptorProto` object which was a source for this generated file
11302fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
11303    static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
11304    file_descriptor_proto_lazy.get(|| {
11305        ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
11306    })
11307}
11308
11309/// `FileDescriptor` object which allows dynamic access to files
11310pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
11311    static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
11312    static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
11313    file_descriptor.get(|| {
11314        let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
11315            let mut deps = ::std::vec::Vec::with_capacity(1);
11316            deps.push(super::messages::file_descriptor().clone());
11317            let mut messages = ::std::vec::Vec::with_capacity(46);
11318            messages.push(Initialize::generated_message_descriptor_data());
11319            messages.push(GetFeatures::generated_message_descriptor_data());
11320            messages.push(Features::generated_message_descriptor_data());
11321            messages.push(LockDevice::generated_message_descriptor_data());
11322            messages.push(SetBusy::generated_message_descriptor_data());
11323            messages.push(EndSession::generated_message_descriptor_data());
11324            messages.push(ApplySettings::generated_message_descriptor_data());
11325            messages.push(ChangeLanguage::generated_message_descriptor_data());
11326            messages.push(TranslationDataRequest::generated_message_descriptor_data());
11327            messages.push(TranslationDataAck::generated_message_descriptor_data());
11328            messages.push(ApplyFlags::generated_message_descriptor_data());
11329            messages.push(ChangePin::generated_message_descriptor_data());
11330            messages.push(ChangeWipeCode::generated_message_descriptor_data());
11331            messages.push(SdProtect::generated_message_descriptor_data());
11332            messages.push(Ping::generated_message_descriptor_data());
11333            messages.push(Cancel::generated_message_descriptor_data());
11334            messages.push(GetEntropy::generated_message_descriptor_data());
11335            messages.push(Entropy::generated_message_descriptor_data());
11336            messages.push(GetFirmwareHash::generated_message_descriptor_data());
11337            messages.push(FirmwareHash::generated_message_descriptor_data());
11338            messages.push(AuthenticateDevice::generated_message_descriptor_data());
11339            messages.push(AuthenticityProof::generated_message_descriptor_data());
11340            messages.push(WipeDevice::generated_message_descriptor_data());
11341            messages.push(LoadDevice::generated_message_descriptor_data());
11342            messages.push(ResetDevice::generated_message_descriptor_data());
11343            messages.push(BackupDevice::generated_message_descriptor_data());
11344            messages.push(EntropyRequest::generated_message_descriptor_data());
11345            messages.push(EntropyAck::generated_message_descriptor_data());
11346            messages.push(RecoveryDevice::generated_message_descriptor_data());
11347            messages.push(WordRequest::generated_message_descriptor_data());
11348            messages.push(WordAck::generated_message_descriptor_data());
11349            messages.push(SetU2FCounter::generated_message_descriptor_data());
11350            messages.push(GetNextU2FCounter::generated_message_descriptor_data());
11351            messages.push(NextU2FCounter::generated_message_descriptor_data());
11352            messages.push(DoPreauthorized::generated_message_descriptor_data());
11353            messages.push(PreauthorizedRequest::generated_message_descriptor_data());
11354            messages.push(CancelAuthorization::generated_message_descriptor_data());
11355            messages.push(RebootToBootloader::generated_message_descriptor_data());
11356            messages.push(GetNonce::generated_message_descriptor_data());
11357            messages.push(Nonce::generated_message_descriptor_data());
11358            messages.push(UnlockPath::generated_message_descriptor_data());
11359            messages.push(UnlockedPathRequest::generated_message_descriptor_data());
11360            messages.push(ShowDeviceTutorial::generated_message_descriptor_data());
11361            messages.push(UnlockBootloader::generated_message_descriptor_data());
11362            messages.push(SetBrightness::generated_message_descriptor_data());
11363            messages.push(backup_device::Slip39Group::generated_message_descriptor_data());
11364            let mut enums = ::std::vec::Vec::with_capacity(11);
11365            enums.push(BackupType::generated_enum_descriptor_data());
11366            enums.push(SafetyCheckLevel::generated_enum_descriptor_data());
11367            enums.push(HomescreenFormat::generated_enum_descriptor_data());
11368            enums.push(RecoveryType::generated_enum_descriptor_data());
11369            enums.push(features::BackupAvailability::generated_enum_descriptor_data());
11370            enums.push(features::RecoveryStatus::generated_enum_descriptor_data());
11371            enums.push(features::Capability::generated_enum_descriptor_data());
11372            enums.push(sd_protect::SdProtectOperationType::generated_enum_descriptor_data());
11373            enums.push(recovery_device::RecoveryDeviceInputMethod::generated_enum_descriptor_data());
11374            enums.push(word_request::WordRequestType::generated_enum_descriptor_data());
11375            enums.push(reboot_to_bootloader::BootCommand::generated_enum_descriptor_data());
11376            ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
11377                file_descriptor_proto(),
11378                deps,
11379                messages,
11380                enums,
11381            )
11382        });
11383        ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
11384    })
11385}
trezor_client/protos/generated/messages_management.rs

trezor_client/protos/generated/
messages_management.rs
