1#![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
22const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_3_3_0;
27
28#[derive(PartialEq,Clone,Default,Debug)]
30pub struct Success {
31 pub message: ::std::option::Option<::std::string::String>,
34 pub special_fields: ::protobuf::SpecialFields,
37}
38
39impl<'a> ::std::default::Default for &'a Success {
40 fn default() -> &'a Success {
41 <Success as ::protobuf::Message>::default_instance()
42 }
43}
44
45impl Success {
46 pub fn new() -> Success {
47 ::std::default::Default::default()
48 }
49
50 pub fn message(&self) -> &str {
53 match self.message.as_ref() {
54 Some(v) => v,
55 None => "",
56 }
57 }
58
59 pub fn clear_message(&mut self) {
60 self.message = ::std::option::Option::None;
61 }
62
63 pub fn has_message(&self) -> bool {
64 self.message.is_some()
65 }
66
67 pub fn set_message(&mut self, v: ::std::string::String) {
69 self.message = ::std::option::Option::Some(v);
70 }
71
72 pub fn mut_message(&mut self) -> &mut ::std::string::String {
75 if self.message.is_none() {
76 self.message = ::std::option::Option::Some(::std::string::String::new());
77 }
78 self.message.as_mut().unwrap()
79 }
80
81 pub fn take_message(&mut self) -> ::std::string::String {
83 self.message.take().unwrap_or_else(|| ::std::string::String::new())
84 }
85
86 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
87 let mut fields = ::std::vec::Vec::with_capacity(1);
88 let mut oneofs = ::std::vec::Vec::with_capacity(0);
89 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
90 "message",
91 |m: &Success| { &m.message },
92 |m: &mut Success| { &mut m.message },
93 ));
94 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Success>(
95 "Success",
96 fields,
97 oneofs,
98 )
99 }
100}
101
102impl ::protobuf::Message for Success {
103 const NAME: &'static str = "Success";
104
105 fn is_initialized(&self) -> bool {
106 true
107 }
108
109 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
110 while let Some(tag) = is.read_raw_tag_or_eof()? {
111 match tag {
112 10 => {
113 self.message = ::std::option::Option::Some(is.read_string()?);
114 },
115 tag => {
116 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
117 },
118 };
119 }
120 ::std::result::Result::Ok(())
121 }
122
123 #[allow(unused_variables)]
125 fn compute_size(&self) -> u64 {
126 let mut my_size = 0;
127 if let Some(v) = self.message.as_ref() {
128 my_size += ::protobuf::rt::string_size(1, &v);
129 }
130 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
131 self.special_fields.cached_size().set(my_size as u32);
132 my_size
133 }
134
135 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
136 if let Some(v) = self.message.as_ref() {
137 os.write_string(1, v)?;
138 }
139 os.write_unknown_fields(self.special_fields.unknown_fields())?;
140 ::std::result::Result::Ok(())
141 }
142
143 fn special_fields(&self) -> &::protobuf::SpecialFields {
144 &self.special_fields
145 }
146
147 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
148 &mut self.special_fields
149 }
150
151 fn new() -> Success {
152 Success::new()
153 }
154
155 fn clear(&mut self) {
156 self.message = ::std::option::Option::None;
157 self.special_fields.clear();
158 }
159
160 fn default_instance() -> &'static Success {
161 static instance: Success = Success {
162 message: ::std::option::Option::None,
163 special_fields: ::protobuf::SpecialFields::new(),
164 };
165 &instance
166 }
167}
168
169impl ::protobuf::MessageFull for Success {
170 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
171 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
172 descriptor.get(|| file_descriptor().message_by_package_relative_name("Success").unwrap()).clone()
173 }
174}
175
176impl ::std::fmt::Display for Success {
177 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
178 ::protobuf::text_format::fmt(self, f)
179 }
180}
181
182impl ::protobuf::reflect::ProtobufValue for Success {
183 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
184}
185
186#[derive(PartialEq,Clone,Default,Debug)]
188pub struct Failure {
189 pub code: ::std::option::Option<::protobuf::EnumOrUnknown<failure::FailureType>>,
192 pub message: ::std::option::Option<::std::string::String>,
194 pub special_fields: ::protobuf::SpecialFields,
197}
198
199impl<'a> ::std::default::Default for &'a Failure {
200 fn default() -> &'a Failure {
201 <Failure as ::protobuf::Message>::default_instance()
202 }
203}
204
205impl Failure {
206 pub fn new() -> Failure {
207 ::std::default::Default::default()
208 }
209
210 pub fn code(&self) -> failure::FailureType {
213 match self.code {
214 Some(e) => e.enum_value_or(failure::FailureType::Failure_UnexpectedMessage),
215 None => failure::FailureType::Failure_UnexpectedMessage,
216 }
217 }
218
219 pub fn clear_code(&mut self) {
220 self.code = ::std::option::Option::None;
221 }
222
223 pub fn has_code(&self) -> bool {
224 self.code.is_some()
225 }
226
227 pub fn set_code(&mut self, v: failure::FailureType) {
229 self.code = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
230 }
231
232 pub fn message(&self) -> &str {
235 match self.message.as_ref() {
236 Some(v) => v,
237 None => "",
238 }
239 }
240
241 pub fn clear_message(&mut self) {
242 self.message = ::std::option::Option::None;
243 }
244
245 pub fn has_message(&self) -> bool {
246 self.message.is_some()
247 }
248
249 pub fn set_message(&mut self, v: ::std::string::String) {
251 self.message = ::std::option::Option::Some(v);
252 }
253
254 pub fn mut_message(&mut self) -> &mut ::std::string::String {
257 if self.message.is_none() {
258 self.message = ::std::option::Option::Some(::std::string::String::new());
259 }
260 self.message.as_mut().unwrap()
261 }
262
263 pub fn take_message(&mut self) -> ::std::string::String {
265 self.message.take().unwrap_or_else(|| ::std::string::String::new())
266 }
267
268 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
269 let mut fields = ::std::vec::Vec::with_capacity(2);
270 let mut oneofs = ::std::vec::Vec::with_capacity(0);
271 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
272 "code",
273 |m: &Failure| { &m.code },
274 |m: &mut Failure| { &mut m.code },
275 ));
276 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
277 "message",
278 |m: &Failure| { &m.message },
279 |m: &mut Failure| { &mut m.message },
280 ));
281 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Failure>(
282 "Failure",
283 fields,
284 oneofs,
285 )
286 }
287}
288
289impl ::protobuf::Message for Failure {
290 const NAME: &'static str = "Failure";
291
292 fn is_initialized(&self) -> bool {
293 true
294 }
295
296 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
297 while let Some(tag) = is.read_raw_tag_or_eof()? {
298 match tag {
299 8 => {
300 self.code = ::std::option::Option::Some(is.read_enum_or_unknown()?);
301 },
302 18 => {
303 self.message = ::std::option::Option::Some(is.read_string()?);
304 },
305 tag => {
306 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
307 },
308 };
309 }
310 ::std::result::Result::Ok(())
311 }
312
313 #[allow(unused_variables)]
315 fn compute_size(&self) -> u64 {
316 let mut my_size = 0;
317 if let Some(v) = self.code {
318 my_size += ::protobuf::rt::int32_size(1, v.value());
319 }
320 if let Some(v) = self.message.as_ref() {
321 my_size += ::protobuf::rt::string_size(2, &v);
322 }
323 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
324 self.special_fields.cached_size().set(my_size as u32);
325 my_size
326 }
327
328 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
329 if let Some(v) = self.code {
330 os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
331 }
332 if let Some(v) = self.message.as_ref() {
333 os.write_string(2, v)?;
334 }
335 os.write_unknown_fields(self.special_fields.unknown_fields())?;
336 ::std::result::Result::Ok(())
337 }
338
339 fn special_fields(&self) -> &::protobuf::SpecialFields {
340 &self.special_fields
341 }
342
343 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
344 &mut self.special_fields
345 }
346
347 fn new() -> Failure {
348 Failure::new()
349 }
350
351 fn clear(&mut self) {
352 self.code = ::std::option::Option::None;
353 self.message = ::std::option::Option::None;
354 self.special_fields.clear();
355 }
356
357 fn default_instance() -> &'static Failure {
358 static instance: Failure = Failure {
359 code: ::std::option::Option::None,
360 message: ::std::option::Option::None,
361 special_fields: ::protobuf::SpecialFields::new(),
362 };
363 &instance
364 }
365}
366
367impl ::protobuf::MessageFull for Failure {
368 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
369 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
370 descriptor.get(|| file_descriptor().message_by_package_relative_name("Failure").unwrap()).clone()
371 }
372}
373
374impl ::std::fmt::Display for Failure {
375 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
376 ::protobuf::text_format::fmt(self, f)
377 }
378}
379
380impl ::protobuf::reflect::ProtobufValue for Failure {
381 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
382}
383
384pub mod failure {
386 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
387 pub enum FailureType {
389 Failure_UnexpectedMessage = 1,
391 Failure_ButtonExpected = 2,
393 Failure_DataError = 3,
395 Failure_ActionCancelled = 4,
397 Failure_PinExpected = 5,
399 Failure_PinCancelled = 6,
401 Failure_PinInvalid = 7,
403 Failure_InvalidSignature = 8,
405 Failure_ProcessError = 9,
407 Failure_NotEnoughFunds = 10,
409 Failure_NotInitialized = 11,
411 Failure_PinMismatch = 12,
413 Failure_WipeCodeMismatch = 13,
415 Failure_InvalidSession = 14,
417 Failure_FirmwareError = 99,
419 }
420
421 impl ::protobuf::Enum for FailureType {
422 const NAME: &'static str = "FailureType";
423
424 fn value(&self) -> i32 {
425 *self as i32
426 }
427
428 fn from_i32(value: i32) -> ::std::option::Option<FailureType> {
429 match value {
430 1 => ::std::option::Option::Some(FailureType::Failure_UnexpectedMessage),
431 2 => ::std::option::Option::Some(FailureType::Failure_ButtonExpected),
432 3 => ::std::option::Option::Some(FailureType::Failure_DataError),
433 4 => ::std::option::Option::Some(FailureType::Failure_ActionCancelled),
434 5 => ::std::option::Option::Some(FailureType::Failure_PinExpected),
435 6 => ::std::option::Option::Some(FailureType::Failure_PinCancelled),
436 7 => ::std::option::Option::Some(FailureType::Failure_PinInvalid),
437 8 => ::std::option::Option::Some(FailureType::Failure_InvalidSignature),
438 9 => ::std::option::Option::Some(FailureType::Failure_ProcessError),
439 10 => ::std::option::Option::Some(FailureType::Failure_NotEnoughFunds),
440 11 => ::std::option::Option::Some(FailureType::Failure_NotInitialized),
441 12 => ::std::option::Option::Some(FailureType::Failure_PinMismatch),
442 13 => ::std::option::Option::Some(FailureType::Failure_WipeCodeMismatch),
443 14 => ::std::option::Option::Some(FailureType::Failure_InvalidSession),
444 99 => ::std::option::Option::Some(FailureType::Failure_FirmwareError),
445 _ => ::std::option::Option::None
446 }
447 }
448
449 fn from_str(str: &str) -> ::std::option::Option<FailureType> {
450 match str {
451 "Failure_UnexpectedMessage" => ::std::option::Option::Some(FailureType::Failure_UnexpectedMessage),
452 "Failure_ButtonExpected" => ::std::option::Option::Some(FailureType::Failure_ButtonExpected),
453 "Failure_DataError" => ::std::option::Option::Some(FailureType::Failure_DataError),
454 "Failure_ActionCancelled" => ::std::option::Option::Some(FailureType::Failure_ActionCancelled),
455 "Failure_PinExpected" => ::std::option::Option::Some(FailureType::Failure_PinExpected),
456 "Failure_PinCancelled" => ::std::option::Option::Some(FailureType::Failure_PinCancelled),
457 "Failure_PinInvalid" => ::std::option::Option::Some(FailureType::Failure_PinInvalid),
458 "Failure_InvalidSignature" => ::std::option::Option::Some(FailureType::Failure_InvalidSignature),
459 "Failure_ProcessError" => ::std::option::Option::Some(FailureType::Failure_ProcessError),
460 "Failure_NotEnoughFunds" => ::std::option::Option::Some(FailureType::Failure_NotEnoughFunds),
461 "Failure_NotInitialized" => ::std::option::Option::Some(FailureType::Failure_NotInitialized),
462 "Failure_PinMismatch" => ::std::option::Option::Some(FailureType::Failure_PinMismatch),
463 "Failure_WipeCodeMismatch" => ::std::option::Option::Some(FailureType::Failure_WipeCodeMismatch),
464 "Failure_InvalidSession" => ::std::option::Option::Some(FailureType::Failure_InvalidSession),
465 "Failure_FirmwareError" => ::std::option::Option::Some(FailureType::Failure_FirmwareError),
466 _ => ::std::option::Option::None
467 }
468 }
469
470 const VALUES: &'static [FailureType] = &[
471 FailureType::Failure_UnexpectedMessage,
472 FailureType::Failure_ButtonExpected,
473 FailureType::Failure_DataError,
474 FailureType::Failure_ActionCancelled,
475 FailureType::Failure_PinExpected,
476 FailureType::Failure_PinCancelled,
477 FailureType::Failure_PinInvalid,
478 FailureType::Failure_InvalidSignature,
479 FailureType::Failure_ProcessError,
480 FailureType::Failure_NotEnoughFunds,
481 FailureType::Failure_NotInitialized,
482 FailureType::Failure_PinMismatch,
483 FailureType::Failure_WipeCodeMismatch,
484 FailureType::Failure_InvalidSession,
485 FailureType::Failure_FirmwareError,
486 ];
487 }
488
489 impl ::protobuf::EnumFull for FailureType {
490 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
491 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
492 descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("Failure.FailureType").unwrap()).clone()
493 }
494
495 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
496 let index = match self {
497 FailureType::Failure_UnexpectedMessage => 0,
498 FailureType::Failure_ButtonExpected => 1,
499 FailureType::Failure_DataError => 2,
500 FailureType::Failure_ActionCancelled => 3,
501 FailureType::Failure_PinExpected => 4,
502 FailureType::Failure_PinCancelled => 5,
503 FailureType::Failure_PinInvalid => 6,
504 FailureType::Failure_InvalidSignature => 7,
505 FailureType::Failure_ProcessError => 8,
506 FailureType::Failure_NotEnoughFunds => 9,
507 FailureType::Failure_NotInitialized => 10,
508 FailureType::Failure_PinMismatch => 11,
509 FailureType::Failure_WipeCodeMismatch => 12,
510 FailureType::Failure_InvalidSession => 13,
511 FailureType::Failure_FirmwareError => 14,
512 };
513 Self::enum_descriptor().value_by_index(index)
514 }
515 }
516
517 impl ::std::default::Default for FailureType {
519 fn default() -> Self {
520 FailureType::Failure_UnexpectedMessage
521 }
522 }
523
524 impl FailureType {
525 pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
526 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<FailureType>("Failure.FailureType")
527 }
528 }
529}
530
531#[derive(PartialEq,Clone,Default,Debug)]
533pub struct ButtonRequest {
534 pub code: ::std::option::Option<::protobuf::EnumOrUnknown<button_request::ButtonRequestType>>,
537 pub pages: ::std::option::Option<u32>,
539 pub special_fields: ::protobuf::SpecialFields,
542}
543
544impl<'a> ::std::default::Default for &'a ButtonRequest {
545 fn default() -> &'a ButtonRequest {
546 <ButtonRequest as ::protobuf::Message>::default_instance()
547 }
548}
549
550impl ButtonRequest {
551 pub fn new() -> ButtonRequest {
552 ::std::default::Default::default()
553 }
554
555 pub fn code(&self) -> button_request::ButtonRequestType {
558 match self.code {
559 Some(e) => e.enum_value_or(button_request::ButtonRequestType::ButtonRequest_Other),
560 None => button_request::ButtonRequestType::ButtonRequest_Other,
561 }
562 }
563
564 pub fn clear_code(&mut self) {
565 self.code = ::std::option::Option::None;
566 }
567
568 pub fn has_code(&self) -> bool {
569 self.code.is_some()
570 }
571
572 pub fn set_code(&mut self, v: button_request::ButtonRequestType) {
574 self.code = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
575 }
576
577 pub fn pages(&self) -> u32 {
580 self.pages.unwrap_or(0)
581 }
582
583 pub fn clear_pages(&mut self) {
584 self.pages = ::std::option::Option::None;
585 }
586
587 pub fn has_pages(&self) -> bool {
588 self.pages.is_some()
589 }
590
591 pub fn set_pages(&mut self, v: u32) {
593 self.pages = ::std::option::Option::Some(v);
594 }
595
596 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
597 let mut fields = ::std::vec::Vec::with_capacity(2);
598 let mut oneofs = ::std::vec::Vec::with_capacity(0);
599 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
600 "code",
601 |m: &ButtonRequest| { &m.code },
602 |m: &mut ButtonRequest| { &mut m.code },
603 ));
604 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
605 "pages",
606 |m: &ButtonRequest| { &m.pages },
607 |m: &mut ButtonRequest| { &mut m.pages },
608 ));
609 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ButtonRequest>(
610 "ButtonRequest",
611 fields,
612 oneofs,
613 )
614 }
615}
616
617impl ::protobuf::Message for ButtonRequest {
618 const NAME: &'static str = "ButtonRequest";
619
620 fn is_initialized(&self) -> bool {
621 true
622 }
623
624 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
625 while let Some(tag) = is.read_raw_tag_or_eof()? {
626 match tag {
627 8 => {
628 self.code = ::std::option::Option::Some(is.read_enum_or_unknown()?);
629 },
630 16 => {
631 self.pages = ::std::option::Option::Some(is.read_uint32()?);
632 },
633 tag => {
634 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
635 },
636 };
637 }
638 ::std::result::Result::Ok(())
639 }
640
641 #[allow(unused_variables)]
643 fn compute_size(&self) -> u64 {
644 let mut my_size = 0;
645 if let Some(v) = self.code {
646 my_size += ::protobuf::rt::int32_size(1, v.value());
647 }
648 if let Some(v) = self.pages {
649 my_size += ::protobuf::rt::uint32_size(2, v);
650 }
651 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
652 self.special_fields.cached_size().set(my_size as u32);
653 my_size
654 }
655
656 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
657 if let Some(v) = self.code {
658 os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
659 }
660 if let Some(v) = self.pages {
661 os.write_uint32(2, v)?;
662 }
663 os.write_unknown_fields(self.special_fields.unknown_fields())?;
664 ::std::result::Result::Ok(())
665 }
666
667 fn special_fields(&self) -> &::protobuf::SpecialFields {
668 &self.special_fields
669 }
670
671 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
672 &mut self.special_fields
673 }
674
675 fn new() -> ButtonRequest {
676 ButtonRequest::new()
677 }
678
679 fn clear(&mut self) {
680 self.code = ::std::option::Option::None;
681 self.pages = ::std::option::Option::None;
682 self.special_fields.clear();
683 }
684
685 fn default_instance() -> &'static ButtonRequest {
686 static instance: ButtonRequest = ButtonRequest {
687 code: ::std::option::Option::None,
688 pages: ::std::option::Option::None,
689 special_fields: ::protobuf::SpecialFields::new(),
690 };
691 &instance
692 }
693}
694
695impl ::protobuf::MessageFull for ButtonRequest {
696 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
697 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
698 descriptor.get(|| file_descriptor().message_by_package_relative_name("ButtonRequest").unwrap()).clone()
699 }
700}
701
702impl ::std::fmt::Display for ButtonRequest {
703 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
704 ::protobuf::text_format::fmt(self, f)
705 }
706}
707
708impl ::protobuf::reflect::ProtobufValue for ButtonRequest {
709 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
710}
711
712pub mod button_request {
714 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
715 pub enum ButtonRequestType {
717 ButtonRequest_Other = 1,
719 ButtonRequest_FeeOverThreshold = 2,
721 ButtonRequest_ConfirmOutput = 3,
723 ButtonRequest_ResetDevice = 4,
725 ButtonRequest_ConfirmWord = 5,
727 ButtonRequest_WipeDevice = 6,
729 ButtonRequest_ProtectCall = 7,
731 ButtonRequest_SignTx = 8,
733 ButtonRequest_FirmwareCheck = 9,
735 ButtonRequest_Address = 10,
737 ButtonRequest_PublicKey = 11,
739 ButtonRequest_MnemonicWordCount = 12,
741 ButtonRequest_MnemonicInput = 13,
743 _Deprecated_ButtonRequest_PassphraseType = 14,
745 ButtonRequest_UnknownDerivationPath = 15,
747 ButtonRequest_RecoveryHomepage = 16,
749 ButtonRequest_Success = 17,
751 ButtonRequest_Warning = 18,
753 ButtonRequest_PassphraseEntry = 19,
755 ButtonRequest_PinEntry = 20,
757 }
758
759 impl ::protobuf::Enum for ButtonRequestType {
760 const NAME: &'static str = "ButtonRequestType";
761
762 fn value(&self) -> i32 {
763 *self as i32
764 }
765
766 fn from_i32(value: i32) -> ::std::option::Option<ButtonRequestType> {
767 match value {
768 1 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Other),
769 2 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_FeeOverThreshold),
770 3 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ConfirmOutput),
771 4 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ResetDevice),
772 5 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ConfirmWord),
773 6 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_WipeDevice),
774 7 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ProtectCall),
775 8 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_SignTx),
776 9 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_FirmwareCheck),
777 10 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Address),
778 11 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PublicKey),
779 12 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_MnemonicWordCount),
780 13 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_MnemonicInput),
781 14 => ::std::option::Option::Some(ButtonRequestType::_Deprecated_ButtonRequest_PassphraseType),
782 15 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_UnknownDerivationPath),
783 16 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_RecoveryHomepage),
784 17 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Success),
785 18 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Warning),
786 19 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PassphraseEntry),
787 20 => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PinEntry),
788 _ => ::std::option::Option::None
789 }
790 }
791
792 fn from_str(str: &str) -> ::std::option::Option<ButtonRequestType> {
793 match str {
794 "ButtonRequest_Other" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Other),
795 "ButtonRequest_FeeOverThreshold" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_FeeOverThreshold),
796 "ButtonRequest_ConfirmOutput" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ConfirmOutput),
797 "ButtonRequest_ResetDevice" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ResetDevice),
798 "ButtonRequest_ConfirmWord" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ConfirmWord),
799 "ButtonRequest_WipeDevice" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_WipeDevice),
800 "ButtonRequest_ProtectCall" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_ProtectCall),
801 "ButtonRequest_SignTx" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_SignTx),
802 "ButtonRequest_FirmwareCheck" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_FirmwareCheck),
803 "ButtonRequest_Address" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Address),
804 "ButtonRequest_PublicKey" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PublicKey),
805 "ButtonRequest_MnemonicWordCount" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_MnemonicWordCount),
806 "ButtonRequest_MnemonicInput" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_MnemonicInput),
807 "_Deprecated_ButtonRequest_PassphraseType" => ::std::option::Option::Some(ButtonRequestType::_Deprecated_ButtonRequest_PassphraseType),
808 "ButtonRequest_UnknownDerivationPath" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_UnknownDerivationPath),
809 "ButtonRequest_RecoveryHomepage" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_RecoveryHomepage),
810 "ButtonRequest_Success" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Success),
811 "ButtonRequest_Warning" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_Warning),
812 "ButtonRequest_PassphraseEntry" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PassphraseEntry),
813 "ButtonRequest_PinEntry" => ::std::option::Option::Some(ButtonRequestType::ButtonRequest_PinEntry),
814 _ => ::std::option::Option::None
815 }
816 }
817
818 const VALUES: &'static [ButtonRequestType] = &[
819 ButtonRequestType::ButtonRequest_Other,
820 ButtonRequestType::ButtonRequest_FeeOverThreshold,
821 ButtonRequestType::ButtonRequest_ConfirmOutput,
822 ButtonRequestType::ButtonRequest_ResetDevice,
823 ButtonRequestType::ButtonRequest_ConfirmWord,
824 ButtonRequestType::ButtonRequest_WipeDevice,
825 ButtonRequestType::ButtonRequest_ProtectCall,
826 ButtonRequestType::ButtonRequest_SignTx,
827 ButtonRequestType::ButtonRequest_FirmwareCheck,
828 ButtonRequestType::ButtonRequest_Address,
829 ButtonRequestType::ButtonRequest_PublicKey,
830 ButtonRequestType::ButtonRequest_MnemonicWordCount,
831 ButtonRequestType::ButtonRequest_MnemonicInput,
832 ButtonRequestType::_Deprecated_ButtonRequest_PassphraseType,
833 ButtonRequestType::ButtonRequest_UnknownDerivationPath,
834 ButtonRequestType::ButtonRequest_RecoveryHomepage,
835 ButtonRequestType::ButtonRequest_Success,
836 ButtonRequestType::ButtonRequest_Warning,
837 ButtonRequestType::ButtonRequest_PassphraseEntry,
838 ButtonRequestType::ButtonRequest_PinEntry,
839 ];
840 }
841
842 impl ::protobuf::EnumFull for ButtonRequestType {
843 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
844 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
845 descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("ButtonRequest.ButtonRequestType").unwrap()).clone()
846 }
847
848 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
849 let index = match self {
850 ButtonRequestType::ButtonRequest_Other => 0,
851 ButtonRequestType::ButtonRequest_FeeOverThreshold => 1,
852 ButtonRequestType::ButtonRequest_ConfirmOutput => 2,
853 ButtonRequestType::ButtonRequest_ResetDevice => 3,
854 ButtonRequestType::ButtonRequest_ConfirmWord => 4,
855 ButtonRequestType::ButtonRequest_WipeDevice => 5,
856 ButtonRequestType::ButtonRequest_ProtectCall => 6,
857 ButtonRequestType::ButtonRequest_SignTx => 7,
858 ButtonRequestType::ButtonRequest_FirmwareCheck => 8,
859 ButtonRequestType::ButtonRequest_Address => 9,
860 ButtonRequestType::ButtonRequest_PublicKey => 10,
861 ButtonRequestType::ButtonRequest_MnemonicWordCount => 11,
862 ButtonRequestType::ButtonRequest_MnemonicInput => 12,
863 ButtonRequestType::_Deprecated_ButtonRequest_PassphraseType => 13,
864 ButtonRequestType::ButtonRequest_UnknownDerivationPath => 14,
865 ButtonRequestType::ButtonRequest_RecoveryHomepage => 15,
866 ButtonRequestType::ButtonRequest_Success => 16,
867 ButtonRequestType::ButtonRequest_Warning => 17,
868 ButtonRequestType::ButtonRequest_PassphraseEntry => 18,
869 ButtonRequestType::ButtonRequest_PinEntry => 19,
870 };
871 Self::enum_descriptor().value_by_index(index)
872 }
873 }
874
875 impl ::std::default::Default for ButtonRequestType {
877 fn default() -> Self {
878 ButtonRequestType::ButtonRequest_Other
879 }
880 }
881
882 impl ButtonRequestType {
883 pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
884 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<ButtonRequestType>("ButtonRequest.ButtonRequestType")
885 }
886 }
887}
888
889#[derive(PartialEq,Clone,Default,Debug)]
891pub struct ButtonAck {
892 pub special_fields: ::protobuf::SpecialFields,
895}
896
897impl<'a> ::std::default::Default for &'a ButtonAck {
898 fn default() -> &'a ButtonAck {
899 <ButtonAck as ::protobuf::Message>::default_instance()
900 }
901}
902
903impl ButtonAck {
904 pub fn new() -> ButtonAck {
905 ::std::default::Default::default()
906 }
907
908 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
909 let mut fields = ::std::vec::Vec::with_capacity(0);
910 let mut oneofs = ::std::vec::Vec::with_capacity(0);
911 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ButtonAck>(
912 "ButtonAck",
913 fields,
914 oneofs,
915 )
916 }
917}
918
919impl ::protobuf::Message for ButtonAck {
920 const NAME: &'static str = "ButtonAck";
921
922 fn is_initialized(&self) -> bool {
923 true
924 }
925
926 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
927 while let Some(tag) = is.read_raw_tag_or_eof()? {
928 match tag {
929 tag => {
930 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
931 },
932 };
933 }
934 ::std::result::Result::Ok(())
935 }
936
937 #[allow(unused_variables)]
939 fn compute_size(&self) -> u64 {
940 let mut my_size = 0;
941 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
942 self.special_fields.cached_size().set(my_size as u32);
943 my_size
944 }
945
946 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
947 os.write_unknown_fields(self.special_fields.unknown_fields())?;
948 ::std::result::Result::Ok(())
949 }
950
951 fn special_fields(&self) -> &::protobuf::SpecialFields {
952 &self.special_fields
953 }
954
955 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
956 &mut self.special_fields
957 }
958
959 fn new() -> ButtonAck {
960 ButtonAck::new()
961 }
962
963 fn clear(&mut self) {
964 self.special_fields.clear();
965 }
966
967 fn default_instance() -> &'static ButtonAck {
968 static instance: ButtonAck = ButtonAck {
969 special_fields: ::protobuf::SpecialFields::new(),
970 };
971 &instance
972 }
973}
974
975impl ::protobuf::MessageFull for ButtonAck {
976 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
977 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
978 descriptor.get(|| file_descriptor().message_by_package_relative_name("ButtonAck").unwrap()).clone()
979 }
980}
981
982impl ::std::fmt::Display for ButtonAck {
983 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
984 ::protobuf::text_format::fmt(self, f)
985 }
986}
987
988impl ::protobuf::reflect::ProtobufValue for ButtonAck {
989 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
990}
991
992#[derive(PartialEq,Clone,Default,Debug)]
994pub struct PinMatrixRequest {
995 pub type_: ::std::option::Option<::protobuf::EnumOrUnknown<pin_matrix_request::PinMatrixRequestType>>,
998 pub special_fields: ::protobuf::SpecialFields,
1001}
1002
1003impl<'a> ::std::default::Default for &'a PinMatrixRequest {
1004 fn default() -> &'a PinMatrixRequest {
1005 <PinMatrixRequest as ::protobuf::Message>::default_instance()
1006 }
1007}
1008
1009impl PinMatrixRequest {
1010 pub fn new() -> PinMatrixRequest {
1011 ::std::default::Default::default()
1012 }
1013
1014 pub fn type_(&self) -> pin_matrix_request::PinMatrixRequestType {
1017 match self.type_ {
1018 Some(e) => e.enum_value_or(pin_matrix_request::PinMatrixRequestType::PinMatrixRequestType_Current),
1019 None => pin_matrix_request::PinMatrixRequestType::PinMatrixRequestType_Current,
1020 }
1021 }
1022
1023 pub fn clear_type_(&mut self) {
1024 self.type_ = ::std::option::Option::None;
1025 }
1026
1027 pub fn has_type(&self) -> bool {
1028 self.type_.is_some()
1029 }
1030
1031 pub fn set_type(&mut self, v: pin_matrix_request::PinMatrixRequestType) {
1033 self.type_ = ::std::option::Option::Some(::protobuf::EnumOrUnknown::new(v));
1034 }
1035
1036 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1037 let mut fields = ::std::vec::Vec::with_capacity(1);
1038 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1039 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1040 "type",
1041 |m: &PinMatrixRequest| { &m.type_ },
1042 |m: &mut PinMatrixRequest| { &mut m.type_ },
1043 ));
1044 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PinMatrixRequest>(
1045 "PinMatrixRequest",
1046 fields,
1047 oneofs,
1048 )
1049 }
1050}
1051
1052impl ::protobuf::Message for PinMatrixRequest {
1053 const NAME: &'static str = "PinMatrixRequest";
1054
1055 fn is_initialized(&self) -> bool {
1056 true
1057 }
1058
1059 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1060 while let Some(tag) = is.read_raw_tag_or_eof()? {
1061 match tag {
1062 8 => {
1063 self.type_ = ::std::option::Option::Some(is.read_enum_or_unknown()?);
1064 },
1065 tag => {
1066 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1067 },
1068 };
1069 }
1070 ::std::result::Result::Ok(())
1071 }
1072
1073 #[allow(unused_variables)]
1075 fn compute_size(&self) -> u64 {
1076 let mut my_size = 0;
1077 if let Some(v) = self.type_ {
1078 my_size += ::protobuf::rt::int32_size(1, v.value());
1079 }
1080 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1081 self.special_fields.cached_size().set(my_size as u32);
1082 my_size
1083 }
1084
1085 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1086 if let Some(v) = self.type_ {
1087 os.write_enum(1, ::protobuf::EnumOrUnknown::value(&v))?;
1088 }
1089 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1090 ::std::result::Result::Ok(())
1091 }
1092
1093 fn special_fields(&self) -> &::protobuf::SpecialFields {
1094 &self.special_fields
1095 }
1096
1097 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1098 &mut self.special_fields
1099 }
1100
1101 fn new() -> PinMatrixRequest {
1102 PinMatrixRequest::new()
1103 }
1104
1105 fn clear(&mut self) {
1106 self.type_ = ::std::option::Option::None;
1107 self.special_fields.clear();
1108 }
1109
1110 fn default_instance() -> &'static PinMatrixRequest {
1111 static instance: PinMatrixRequest = PinMatrixRequest {
1112 type_: ::std::option::Option::None,
1113 special_fields: ::protobuf::SpecialFields::new(),
1114 };
1115 &instance
1116 }
1117}
1118
1119impl ::protobuf::MessageFull for PinMatrixRequest {
1120 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1121 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1122 descriptor.get(|| file_descriptor().message_by_package_relative_name("PinMatrixRequest").unwrap()).clone()
1123 }
1124}
1125
1126impl ::std::fmt::Display for PinMatrixRequest {
1127 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1128 ::protobuf::text_format::fmt(self, f)
1129 }
1130}
1131
1132impl ::protobuf::reflect::ProtobufValue for PinMatrixRequest {
1133 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1134}
1135
1136pub mod pin_matrix_request {
1138 #[derive(Clone,Copy,PartialEq,Eq,Debug,Hash)]
1139 pub enum PinMatrixRequestType {
1141 PinMatrixRequestType_Current = 1,
1143 PinMatrixRequestType_NewFirst = 2,
1145 PinMatrixRequestType_NewSecond = 3,
1147 PinMatrixRequestType_WipeCodeFirst = 4,
1149 PinMatrixRequestType_WipeCodeSecond = 5,
1151 }
1152
1153 impl ::protobuf::Enum for PinMatrixRequestType {
1154 const NAME: &'static str = "PinMatrixRequestType";
1155
1156 fn value(&self) -> i32 {
1157 *self as i32
1158 }
1159
1160 fn from_i32(value: i32) -> ::std::option::Option<PinMatrixRequestType> {
1161 match value {
1162 1 => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_Current),
1163 2 => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_NewFirst),
1164 3 => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_NewSecond),
1165 4 => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_WipeCodeFirst),
1166 5 => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_WipeCodeSecond),
1167 _ => ::std::option::Option::None
1168 }
1169 }
1170
1171 fn from_str(str: &str) -> ::std::option::Option<PinMatrixRequestType> {
1172 match str {
1173 "PinMatrixRequestType_Current" => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_Current),
1174 "PinMatrixRequestType_NewFirst" => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_NewFirst),
1175 "PinMatrixRequestType_NewSecond" => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_NewSecond),
1176 "PinMatrixRequestType_WipeCodeFirst" => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_WipeCodeFirst),
1177 "PinMatrixRequestType_WipeCodeSecond" => ::std::option::Option::Some(PinMatrixRequestType::PinMatrixRequestType_WipeCodeSecond),
1178 _ => ::std::option::Option::None
1179 }
1180 }
1181
1182 const VALUES: &'static [PinMatrixRequestType] = &[
1183 PinMatrixRequestType::PinMatrixRequestType_Current,
1184 PinMatrixRequestType::PinMatrixRequestType_NewFirst,
1185 PinMatrixRequestType::PinMatrixRequestType_NewSecond,
1186 PinMatrixRequestType::PinMatrixRequestType_WipeCodeFirst,
1187 PinMatrixRequestType::PinMatrixRequestType_WipeCodeSecond,
1188 ];
1189 }
1190
1191 impl ::protobuf::EnumFull for PinMatrixRequestType {
1192 fn enum_descriptor() -> ::protobuf::reflect::EnumDescriptor {
1193 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::rt::Lazy::new();
1194 descriptor.get(|| super::file_descriptor().enum_by_package_relative_name("PinMatrixRequest.PinMatrixRequestType").unwrap()).clone()
1195 }
1196
1197 fn descriptor(&self) -> ::protobuf::reflect::EnumValueDescriptor {
1198 let index = match self {
1199 PinMatrixRequestType::PinMatrixRequestType_Current => 0,
1200 PinMatrixRequestType::PinMatrixRequestType_NewFirst => 1,
1201 PinMatrixRequestType::PinMatrixRequestType_NewSecond => 2,
1202 PinMatrixRequestType::PinMatrixRequestType_WipeCodeFirst => 3,
1203 PinMatrixRequestType::PinMatrixRequestType_WipeCodeSecond => 4,
1204 };
1205 Self::enum_descriptor().value_by_index(index)
1206 }
1207 }
1208
1209 impl ::std::default::Default for PinMatrixRequestType {
1211 fn default() -> Self {
1212 PinMatrixRequestType::PinMatrixRequestType_Current
1213 }
1214 }
1215
1216 impl PinMatrixRequestType {
1217 pub(in super) fn generated_enum_descriptor_data() -> ::protobuf::reflect::GeneratedEnumDescriptorData {
1218 ::protobuf::reflect::GeneratedEnumDescriptorData::new::<PinMatrixRequestType>("PinMatrixRequest.PinMatrixRequestType")
1219 }
1220 }
1221}
1222
1223#[derive(PartialEq,Clone,Default,Debug)]
1225pub struct PinMatrixAck {
1226 pub pin: ::std::option::Option<::std::string::String>,
1229 pub special_fields: ::protobuf::SpecialFields,
1232}
1233
1234impl<'a> ::std::default::Default for &'a PinMatrixAck {
1235 fn default() -> &'a PinMatrixAck {
1236 <PinMatrixAck as ::protobuf::Message>::default_instance()
1237 }
1238}
1239
1240impl PinMatrixAck {
1241 pub fn new() -> PinMatrixAck {
1242 ::std::default::Default::default()
1243 }
1244
1245 pub fn pin(&self) -> &str {
1248 match self.pin.as_ref() {
1249 Some(v) => v,
1250 None => "",
1251 }
1252 }
1253
1254 pub fn clear_pin(&mut self) {
1255 self.pin = ::std::option::Option::None;
1256 }
1257
1258 pub fn has_pin(&self) -> bool {
1259 self.pin.is_some()
1260 }
1261
1262 pub fn set_pin(&mut self, v: ::std::string::String) {
1264 self.pin = ::std::option::Option::Some(v);
1265 }
1266
1267 pub fn mut_pin(&mut self) -> &mut ::std::string::String {
1270 if self.pin.is_none() {
1271 self.pin = ::std::option::Option::Some(::std::string::String::new());
1272 }
1273 self.pin.as_mut().unwrap()
1274 }
1275
1276 pub fn take_pin(&mut self) -> ::std::string::String {
1278 self.pin.take().unwrap_or_else(|| ::std::string::String::new())
1279 }
1280
1281 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1282 let mut fields = ::std::vec::Vec::with_capacity(1);
1283 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1284 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1285 "pin",
1286 |m: &PinMatrixAck| { &m.pin },
1287 |m: &mut PinMatrixAck| { &mut m.pin },
1288 ));
1289 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PinMatrixAck>(
1290 "PinMatrixAck",
1291 fields,
1292 oneofs,
1293 )
1294 }
1295}
1296
1297impl ::protobuf::Message for PinMatrixAck {
1298 const NAME: &'static str = "PinMatrixAck";
1299
1300 fn is_initialized(&self) -> bool {
1301 if self.pin.is_none() {
1302 return false;
1303 }
1304 true
1305 }
1306
1307 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1308 while let Some(tag) = is.read_raw_tag_or_eof()? {
1309 match tag {
1310 10 => {
1311 self.pin = ::std::option::Option::Some(is.read_string()?);
1312 },
1313 tag => {
1314 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1315 },
1316 };
1317 }
1318 ::std::result::Result::Ok(())
1319 }
1320
1321 #[allow(unused_variables)]
1323 fn compute_size(&self) -> u64 {
1324 let mut my_size = 0;
1325 if let Some(v) = self.pin.as_ref() {
1326 my_size += ::protobuf::rt::string_size(1, &v);
1327 }
1328 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1329 self.special_fields.cached_size().set(my_size as u32);
1330 my_size
1331 }
1332
1333 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1334 if let Some(v) = self.pin.as_ref() {
1335 os.write_string(1, v)?;
1336 }
1337 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1338 ::std::result::Result::Ok(())
1339 }
1340
1341 fn special_fields(&self) -> &::protobuf::SpecialFields {
1342 &self.special_fields
1343 }
1344
1345 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1346 &mut self.special_fields
1347 }
1348
1349 fn new() -> PinMatrixAck {
1350 PinMatrixAck::new()
1351 }
1352
1353 fn clear(&mut self) {
1354 self.pin = ::std::option::Option::None;
1355 self.special_fields.clear();
1356 }
1357
1358 fn default_instance() -> &'static PinMatrixAck {
1359 static instance: PinMatrixAck = PinMatrixAck {
1360 pin: ::std::option::Option::None,
1361 special_fields: ::protobuf::SpecialFields::new(),
1362 };
1363 &instance
1364 }
1365}
1366
1367impl ::protobuf::MessageFull for PinMatrixAck {
1368 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1369 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1370 descriptor.get(|| file_descriptor().message_by_package_relative_name("PinMatrixAck").unwrap()).clone()
1371 }
1372}
1373
1374impl ::std::fmt::Display for PinMatrixAck {
1375 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1376 ::protobuf::text_format::fmt(self, f)
1377 }
1378}
1379
1380impl ::protobuf::reflect::ProtobufValue for PinMatrixAck {
1381 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1382}
1383
1384#[derive(PartialEq,Clone,Default,Debug)]
1386pub struct PassphraseRequest {
1387 pub _on_device: ::std::option::Option<bool>,
1390 pub special_fields: ::protobuf::SpecialFields,
1393}
1394
1395impl<'a> ::std::default::Default for &'a PassphraseRequest {
1396 fn default() -> &'a PassphraseRequest {
1397 <PassphraseRequest as ::protobuf::Message>::default_instance()
1398 }
1399}
1400
1401impl PassphraseRequest {
1402 pub fn new() -> PassphraseRequest {
1403 ::std::default::Default::default()
1404 }
1405
1406 pub fn _on_device(&self) -> bool {
1409 self._on_device.unwrap_or(false)
1410 }
1411
1412 pub fn clear__on_device(&mut self) {
1413 self._on_device = ::std::option::Option::None;
1414 }
1415
1416 pub fn has__on_device(&self) -> bool {
1417 self._on_device.is_some()
1418 }
1419
1420 pub fn set__on_device(&mut self, v: bool) {
1422 self._on_device = ::std::option::Option::Some(v);
1423 }
1424
1425 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1426 let mut fields = ::std::vec::Vec::with_capacity(1);
1427 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1428 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1429 "_on_device",
1430 |m: &PassphraseRequest| { &m._on_device },
1431 |m: &mut PassphraseRequest| { &mut m._on_device },
1432 ));
1433 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PassphraseRequest>(
1434 "PassphraseRequest",
1435 fields,
1436 oneofs,
1437 )
1438 }
1439}
1440
1441impl ::protobuf::Message for PassphraseRequest {
1442 const NAME: &'static str = "PassphraseRequest";
1443
1444 fn is_initialized(&self) -> bool {
1445 true
1446 }
1447
1448 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1449 while let Some(tag) = is.read_raw_tag_or_eof()? {
1450 match tag {
1451 8 => {
1452 self._on_device = ::std::option::Option::Some(is.read_bool()?);
1453 },
1454 tag => {
1455 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1456 },
1457 };
1458 }
1459 ::std::result::Result::Ok(())
1460 }
1461
1462 #[allow(unused_variables)]
1464 fn compute_size(&self) -> u64 {
1465 let mut my_size = 0;
1466 if let Some(v) = self._on_device {
1467 my_size += 1 + 1;
1468 }
1469 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1470 self.special_fields.cached_size().set(my_size as u32);
1471 my_size
1472 }
1473
1474 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1475 if let Some(v) = self._on_device {
1476 os.write_bool(1, v)?;
1477 }
1478 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1479 ::std::result::Result::Ok(())
1480 }
1481
1482 fn special_fields(&self) -> &::protobuf::SpecialFields {
1483 &self.special_fields
1484 }
1485
1486 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1487 &mut self.special_fields
1488 }
1489
1490 fn new() -> PassphraseRequest {
1491 PassphraseRequest::new()
1492 }
1493
1494 fn clear(&mut self) {
1495 self._on_device = ::std::option::Option::None;
1496 self.special_fields.clear();
1497 }
1498
1499 fn default_instance() -> &'static PassphraseRequest {
1500 static instance: PassphraseRequest = PassphraseRequest {
1501 _on_device: ::std::option::Option::None,
1502 special_fields: ::protobuf::SpecialFields::new(),
1503 };
1504 &instance
1505 }
1506}
1507
1508impl ::protobuf::MessageFull for PassphraseRequest {
1509 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1510 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1511 descriptor.get(|| file_descriptor().message_by_package_relative_name("PassphraseRequest").unwrap()).clone()
1512 }
1513}
1514
1515impl ::std::fmt::Display for PassphraseRequest {
1516 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1517 ::protobuf::text_format::fmt(self, f)
1518 }
1519}
1520
1521impl ::protobuf::reflect::ProtobufValue for PassphraseRequest {
1522 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1523}
1524
1525#[derive(PartialEq,Clone,Default,Debug)]
1527pub struct PassphraseAck {
1528 pub passphrase: ::std::option::Option<::std::string::String>,
1531 pub _state: ::std::option::Option<::std::vec::Vec<u8>>,
1533 pub on_device: ::std::option::Option<bool>,
1535 pub special_fields: ::protobuf::SpecialFields,
1538}
1539
1540impl<'a> ::std::default::Default for &'a PassphraseAck {
1541 fn default() -> &'a PassphraseAck {
1542 <PassphraseAck as ::protobuf::Message>::default_instance()
1543 }
1544}
1545
1546impl PassphraseAck {
1547 pub fn new() -> PassphraseAck {
1548 ::std::default::Default::default()
1549 }
1550
1551 pub fn passphrase(&self) -> &str {
1554 match self.passphrase.as_ref() {
1555 Some(v) => v,
1556 None => "",
1557 }
1558 }
1559
1560 pub fn clear_passphrase(&mut self) {
1561 self.passphrase = ::std::option::Option::None;
1562 }
1563
1564 pub fn has_passphrase(&self) -> bool {
1565 self.passphrase.is_some()
1566 }
1567
1568 pub fn set_passphrase(&mut self, v: ::std::string::String) {
1570 self.passphrase = ::std::option::Option::Some(v);
1571 }
1572
1573 pub fn mut_passphrase(&mut self) -> &mut ::std::string::String {
1576 if self.passphrase.is_none() {
1577 self.passphrase = ::std::option::Option::Some(::std::string::String::new());
1578 }
1579 self.passphrase.as_mut().unwrap()
1580 }
1581
1582 pub fn take_passphrase(&mut self) -> ::std::string::String {
1584 self.passphrase.take().unwrap_or_else(|| ::std::string::String::new())
1585 }
1586
1587 pub fn _state(&self) -> &[u8] {
1590 match self._state.as_ref() {
1591 Some(v) => v,
1592 None => &[],
1593 }
1594 }
1595
1596 pub fn clear__state(&mut self) {
1597 self._state = ::std::option::Option::None;
1598 }
1599
1600 pub fn has__state(&self) -> bool {
1601 self._state.is_some()
1602 }
1603
1604 pub fn set__state(&mut self, v: ::std::vec::Vec<u8>) {
1606 self._state = ::std::option::Option::Some(v);
1607 }
1608
1609 pub fn mut__state(&mut self) -> &mut ::std::vec::Vec<u8> {
1612 if self._state.is_none() {
1613 self._state = ::std::option::Option::Some(::std::vec::Vec::new());
1614 }
1615 self._state.as_mut().unwrap()
1616 }
1617
1618 pub fn take__state(&mut self) -> ::std::vec::Vec<u8> {
1620 self._state.take().unwrap_or_else(|| ::std::vec::Vec::new())
1621 }
1622
1623 pub fn on_device(&self) -> bool {
1626 self.on_device.unwrap_or(false)
1627 }
1628
1629 pub fn clear_on_device(&mut self) {
1630 self.on_device = ::std::option::Option::None;
1631 }
1632
1633 pub fn has_on_device(&self) -> bool {
1634 self.on_device.is_some()
1635 }
1636
1637 pub fn set_on_device(&mut self, v: bool) {
1639 self.on_device = ::std::option::Option::Some(v);
1640 }
1641
1642 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1643 let mut fields = ::std::vec::Vec::with_capacity(3);
1644 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1645 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1646 "passphrase",
1647 |m: &PassphraseAck| { &m.passphrase },
1648 |m: &mut PassphraseAck| { &mut m.passphrase },
1649 ));
1650 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1651 "_state",
1652 |m: &PassphraseAck| { &m._state },
1653 |m: &mut PassphraseAck| { &mut m._state },
1654 ));
1655 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1656 "on_device",
1657 |m: &PassphraseAck| { &m.on_device },
1658 |m: &mut PassphraseAck| { &mut m.on_device },
1659 ));
1660 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<PassphraseAck>(
1661 "PassphraseAck",
1662 fields,
1663 oneofs,
1664 )
1665 }
1666}
1667
1668impl ::protobuf::Message for PassphraseAck {
1669 const NAME: &'static str = "PassphraseAck";
1670
1671 fn is_initialized(&self) -> bool {
1672 true
1673 }
1674
1675 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1676 while let Some(tag) = is.read_raw_tag_or_eof()? {
1677 match tag {
1678 10 => {
1679 self.passphrase = ::std::option::Option::Some(is.read_string()?);
1680 },
1681 18 => {
1682 self._state = ::std::option::Option::Some(is.read_bytes()?);
1683 },
1684 24 => {
1685 self.on_device = ::std::option::Option::Some(is.read_bool()?);
1686 },
1687 tag => {
1688 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1689 },
1690 };
1691 }
1692 ::std::result::Result::Ok(())
1693 }
1694
1695 #[allow(unused_variables)]
1697 fn compute_size(&self) -> u64 {
1698 let mut my_size = 0;
1699 if let Some(v) = self.passphrase.as_ref() {
1700 my_size += ::protobuf::rt::string_size(1, &v);
1701 }
1702 if let Some(v) = self._state.as_ref() {
1703 my_size += ::protobuf::rt::bytes_size(2, &v);
1704 }
1705 if let Some(v) = self.on_device {
1706 my_size += 1 + 1;
1707 }
1708 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1709 self.special_fields.cached_size().set(my_size as u32);
1710 my_size
1711 }
1712
1713 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1714 if let Some(v) = self.passphrase.as_ref() {
1715 os.write_string(1, v)?;
1716 }
1717 if let Some(v) = self._state.as_ref() {
1718 os.write_bytes(2, v)?;
1719 }
1720 if let Some(v) = self.on_device {
1721 os.write_bool(3, v)?;
1722 }
1723 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1724 ::std::result::Result::Ok(())
1725 }
1726
1727 fn special_fields(&self) -> &::protobuf::SpecialFields {
1728 &self.special_fields
1729 }
1730
1731 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1732 &mut self.special_fields
1733 }
1734
1735 fn new() -> PassphraseAck {
1736 PassphraseAck::new()
1737 }
1738
1739 fn clear(&mut self) {
1740 self.passphrase = ::std::option::Option::None;
1741 self._state = ::std::option::Option::None;
1742 self.on_device = ::std::option::Option::None;
1743 self.special_fields.clear();
1744 }
1745
1746 fn default_instance() -> &'static PassphraseAck {
1747 static instance: PassphraseAck = PassphraseAck {
1748 passphrase: ::std::option::Option::None,
1749 _state: ::std::option::Option::None,
1750 on_device: ::std::option::Option::None,
1751 special_fields: ::protobuf::SpecialFields::new(),
1752 };
1753 &instance
1754 }
1755}
1756
1757impl ::protobuf::MessageFull for PassphraseAck {
1758 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1759 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1760 descriptor.get(|| file_descriptor().message_by_package_relative_name("PassphraseAck").unwrap()).clone()
1761 }
1762}
1763
1764impl ::std::fmt::Display for PassphraseAck {
1765 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1766 ::protobuf::text_format::fmt(self, f)
1767 }
1768}
1769
1770impl ::protobuf::reflect::ProtobufValue for PassphraseAck {
1771 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1772}
1773
1774#[derive(PartialEq,Clone,Default,Debug)]
1776pub struct Deprecated_PassphraseStateRequest {
1777 pub state: ::std::option::Option<::std::vec::Vec<u8>>,
1780 pub special_fields: ::protobuf::SpecialFields,
1783}
1784
1785impl<'a> ::std::default::Default for &'a Deprecated_PassphraseStateRequest {
1786 fn default() -> &'a Deprecated_PassphraseStateRequest {
1787 <Deprecated_PassphraseStateRequest as ::protobuf::Message>::default_instance()
1788 }
1789}
1790
1791impl Deprecated_PassphraseStateRequest {
1792 pub fn new() -> Deprecated_PassphraseStateRequest {
1793 ::std::default::Default::default()
1794 }
1795
1796 pub fn state(&self) -> &[u8] {
1799 match self.state.as_ref() {
1800 Some(v) => v,
1801 None => &[],
1802 }
1803 }
1804
1805 pub fn clear_state(&mut self) {
1806 self.state = ::std::option::Option::None;
1807 }
1808
1809 pub fn has_state(&self) -> bool {
1810 self.state.is_some()
1811 }
1812
1813 pub fn set_state(&mut self, v: ::std::vec::Vec<u8>) {
1815 self.state = ::std::option::Option::Some(v);
1816 }
1817
1818 pub fn mut_state(&mut self) -> &mut ::std::vec::Vec<u8> {
1821 if self.state.is_none() {
1822 self.state = ::std::option::Option::Some(::std::vec::Vec::new());
1823 }
1824 self.state.as_mut().unwrap()
1825 }
1826
1827 pub fn take_state(&mut self) -> ::std::vec::Vec<u8> {
1829 self.state.take().unwrap_or_else(|| ::std::vec::Vec::new())
1830 }
1831
1832 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1833 let mut fields = ::std::vec::Vec::with_capacity(1);
1834 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1835 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
1836 "state",
1837 |m: &Deprecated_PassphraseStateRequest| { &m.state },
1838 |m: &mut Deprecated_PassphraseStateRequest| { &mut m.state },
1839 ));
1840 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Deprecated_PassphraseStateRequest>(
1841 "Deprecated_PassphraseStateRequest",
1842 fields,
1843 oneofs,
1844 )
1845 }
1846}
1847
1848impl ::protobuf::Message for Deprecated_PassphraseStateRequest {
1849 const NAME: &'static str = "Deprecated_PassphraseStateRequest";
1850
1851 fn is_initialized(&self) -> bool {
1852 true
1853 }
1854
1855 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1856 while let Some(tag) = is.read_raw_tag_or_eof()? {
1857 match tag {
1858 10 => {
1859 self.state = ::std::option::Option::Some(is.read_bytes()?);
1860 },
1861 tag => {
1862 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1863 },
1864 };
1865 }
1866 ::std::result::Result::Ok(())
1867 }
1868
1869 #[allow(unused_variables)]
1871 fn compute_size(&self) -> u64 {
1872 let mut my_size = 0;
1873 if let Some(v) = self.state.as_ref() {
1874 my_size += ::protobuf::rt::bytes_size(1, &v);
1875 }
1876 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1877 self.special_fields.cached_size().set(my_size as u32);
1878 my_size
1879 }
1880
1881 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1882 if let Some(v) = self.state.as_ref() {
1883 os.write_bytes(1, v)?;
1884 }
1885 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1886 ::std::result::Result::Ok(())
1887 }
1888
1889 fn special_fields(&self) -> &::protobuf::SpecialFields {
1890 &self.special_fields
1891 }
1892
1893 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1894 &mut self.special_fields
1895 }
1896
1897 fn new() -> Deprecated_PassphraseStateRequest {
1898 Deprecated_PassphraseStateRequest::new()
1899 }
1900
1901 fn clear(&mut self) {
1902 self.state = ::std::option::Option::None;
1903 self.special_fields.clear();
1904 }
1905
1906 fn default_instance() -> &'static Deprecated_PassphraseStateRequest {
1907 static instance: Deprecated_PassphraseStateRequest = Deprecated_PassphraseStateRequest {
1908 state: ::std::option::Option::None,
1909 special_fields: ::protobuf::SpecialFields::new(),
1910 };
1911 &instance
1912 }
1913}
1914
1915impl ::protobuf::MessageFull for Deprecated_PassphraseStateRequest {
1916 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
1917 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
1918 descriptor.get(|| file_descriptor().message_by_package_relative_name("Deprecated_PassphraseStateRequest").unwrap()).clone()
1919 }
1920}
1921
1922impl ::std::fmt::Display for Deprecated_PassphraseStateRequest {
1923 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
1924 ::protobuf::text_format::fmt(self, f)
1925 }
1926}
1927
1928impl ::protobuf::reflect::ProtobufValue for Deprecated_PassphraseStateRequest {
1929 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
1930}
1931
1932#[derive(PartialEq,Clone,Default,Debug)]
1934pub struct Deprecated_PassphraseStateAck {
1935 pub special_fields: ::protobuf::SpecialFields,
1938}
1939
1940impl<'a> ::std::default::Default for &'a Deprecated_PassphraseStateAck {
1941 fn default() -> &'a Deprecated_PassphraseStateAck {
1942 <Deprecated_PassphraseStateAck as ::protobuf::Message>::default_instance()
1943 }
1944}
1945
1946impl Deprecated_PassphraseStateAck {
1947 pub fn new() -> Deprecated_PassphraseStateAck {
1948 ::std::default::Default::default()
1949 }
1950
1951 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
1952 let mut fields = ::std::vec::Vec::with_capacity(0);
1953 let mut oneofs = ::std::vec::Vec::with_capacity(0);
1954 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<Deprecated_PassphraseStateAck>(
1955 "Deprecated_PassphraseStateAck",
1956 fields,
1957 oneofs,
1958 )
1959 }
1960}
1961
1962impl ::protobuf::Message for Deprecated_PassphraseStateAck {
1963 const NAME: &'static str = "Deprecated_PassphraseStateAck";
1964
1965 fn is_initialized(&self) -> bool {
1966 true
1967 }
1968
1969 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
1970 while let Some(tag) = is.read_raw_tag_or_eof()? {
1971 match tag {
1972 tag => {
1973 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
1974 },
1975 };
1976 }
1977 ::std::result::Result::Ok(())
1978 }
1979
1980 #[allow(unused_variables)]
1982 fn compute_size(&self) -> u64 {
1983 let mut my_size = 0;
1984 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
1985 self.special_fields.cached_size().set(my_size as u32);
1986 my_size
1987 }
1988
1989 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
1990 os.write_unknown_fields(self.special_fields.unknown_fields())?;
1991 ::std::result::Result::Ok(())
1992 }
1993
1994 fn special_fields(&self) -> &::protobuf::SpecialFields {
1995 &self.special_fields
1996 }
1997
1998 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
1999 &mut self.special_fields
2000 }
2001
2002 fn new() -> Deprecated_PassphraseStateAck {
2003 Deprecated_PassphraseStateAck::new()
2004 }
2005
2006 fn clear(&mut self) {
2007 self.special_fields.clear();
2008 }
2009
2010 fn default_instance() -> &'static Deprecated_PassphraseStateAck {
2011 static instance: Deprecated_PassphraseStateAck = Deprecated_PassphraseStateAck {
2012 special_fields: ::protobuf::SpecialFields::new(),
2013 };
2014 &instance
2015 }
2016}
2017
2018impl ::protobuf::MessageFull for Deprecated_PassphraseStateAck {
2019 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2020 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2021 descriptor.get(|| file_descriptor().message_by_package_relative_name("Deprecated_PassphraseStateAck").unwrap()).clone()
2022 }
2023}
2024
2025impl ::std::fmt::Display for Deprecated_PassphraseStateAck {
2026 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2027 ::protobuf::text_format::fmt(self, f)
2028 }
2029}
2030
2031impl ::protobuf::reflect::ProtobufValue for Deprecated_PassphraseStateAck {
2032 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2033}
2034
2035#[derive(PartialEq,Clone,Default,Debug)]
2037pub struct HDNodeType {
2038 pub depth: ::std::option::Option<u32>,
2041 pub fingerprint: ::std::option::Option<u32>,
2043 pub child_num: ::std::option::Option<u32>,
2045 pub chain_code: ::std::option::Option<::std::vec::Vec<u8>>,
2047 pub private_key: ::std::option::Option<::std::vec::Vec<u8>>,
2049 pub public_key: ::std::option::Option<::std::vec::Vec<u8>>,
2051 pub special_fields: ::protobuf::SpecialFields,
2054}
2055
2056impl<'a> ::std::default::Default for &'a HDNodeType {
2057 fn default() -> &'a HDNodeType {
2058 <HDNodeType as ::protobuf::Message>::default_instance()
2059 }
2060}
2061
2062impl HDNodeType {
2063 pub fn new() -> HDNodeType {
2064 ::std::default::Default::default()
2065 }
2066
2067 pub fn depth(&self) -> u32 {
2070 self.depth.unwrap_or(0)
2071 }
2072
2073 pub fn clear_depth(&mut self) {
2074 self.depth = ::std::option::Option::None;
2075 }
2076
2077 pub fn has_depth(&self) -> bool {
2078 self.depth.is_some()
2079 }
2080
2081 pub fn set_depth(&mut self, v: u32) {
2083 self.depth = ::std::option::Option::Some(v);
2084 }
2085
2086 pub fn fingerprint(&self) -> u32 {
2089 self.fingerprint.unwrap_or(0)
2090 }
2091
2092 pub fn clear_fingerprint(&mut self) {
2093 self.fingerprint = ::std::option::Option::None;
2094 }
2095
2096 pub fn has_fingerprint(&self) -> bool {
2097 self.fingerprint.is_some()
2098 }
2099
2100 pub fn set_fingerprint(&mut self, v: u32) {
2102 self.fingerprint = ::std::option::Option::Some(v);
2103 }
2104
2105 pub fn child_num(&self) -> u32 {
2108 self.child_num.unwrap_or(0)
2109 }
2110
2111 pub fn clear_child_num(&mut self) {
2112 self.child_num = ::std::option::Option::None;
2113 }
2114
2115 pub fn has_child_num(&self) -> bool {
2116 self.child_num.is_some()
2117 }
2118
2119 pub fn set_child_num(&mut self, v: u32) {
2121 self.child_num = ::std::option::Option::Some(v);
2122 }
2123
2124 pub fn chain_code(&self) -> &[u8] {
2127 match self.chain_code.as_ref() {
2128 Some(v) => v,
2129 None => &[],
2130 }
2131 }
2132
2133 pub fn clear_chain_code(&mut self) {
2134 self.chain_code = ::std::option::Option::None;
2135 }
2136
2137 pub fn has_chain_code(&self) -> bool {
2138 self.chain_code.is_some()
2139 }
2140
2141 pub fn set_chain_code(&mut self, v: ::std::vec::Vec<u8>) {
2143 self.chain_code = ::std::option::Option::Some(v);
2144 }
2145
2146 pub fn mut_chain_code(&mut self) -> &mut ::std::vec::Vec<u8> {
2149 if self.chain_code.is_none() {
2150 self.chain_code = ::std::option::Option::Some(::std::vec::Vec::new());
2151 }
2152 self.chain_code.as_mut().unwrap()
2153 }
2154
2155 pub fn take_chain_code(&mut self) -> ::std::vec::Vec<u8> {
2157 self.chain_code.take().unwrap_or_else(|| ::std::vec::Vec::new())
2158 }
2159
2160 pub fn private_key(&self) -> &[u8] {
2163 match self.private_key.as_ref() {
2164 Some(v) => v,
2165 None => &[],
2166 }
2167 }
2168
2169 pub fn clear_private_key(&mut self) {
2170 self.private_key = ::std::option::Option::None;
2171 }
2172
2173 pub fn has_private_key(&self) -> bool {
2174 self.private_key.is_some()
2175 }
2176
2177 pub fn set_private_key(&mut self, v: ::std::vec::Vec<u8>) {
2179 self.private_key = ::std::option::Option::Some(v);
2180 }
2181
2182 pub fn mut_private_key(&mut self) -> &mut ::std::vec::Vec<u8> {
2185 if self.private_key.is_none() {
2186 self.private_key = ::std::option::Option::Some(::std::vec::Vec::new());
2187 }
2188 self.private_key.as_mut().unwrap()
2189 }
2190
2191 pub fn take_private_key(&mut self) -> ::std::vec::Vec<u8> {
2193 self.private_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
2194 }
2195
2196 pub fn public_key(&self) -> &[u8] {
2199 match self.public_key.as_ref() {
2200 Some(v) => v,
2201 None => &[],
2202 }
2203 }
2204
2205 pub fn clear_public_key(&mut self) {
2206 self.public_key = ::std::option::Option::None;
2207 }
2208
2209 pub fn has_public_key(&self) -> bool {
2210 self.public_key.is_some()
2211 }
2212
2213 pub fn set_public_key(&mut self, v: ::std::vec::Vec<u8>) {
2215 self.public_key = ::std::option::Option::Some(v);
2216 }
2217
2218 pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec<u8> {
2221 if self.public_key.is_none() {
2222 self.public_key = ::std::option::Option::Some(::std::vec::Vec::new());
2223 }
2224 self.public_key.as_mut().unwrap()
2225 }
2226
2227 pub fn take_public_key(&mut self) -> ::std::vec::Vec<u8> {
2229 self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new())
2230 }
2231
2232 fn generated_message_descriptor_data() -> ::protobuf::reflect::GeneratedMessageDescriptorData {
2233 let mut fields = ::std::vec::Vec::with_capacity(6);
2234 let mut oneofs = ::std::vec::Vec::with_capacity(0);
2235 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2236 "depth",
2237 |m: &HDNodeType| { &m.depth },
2238 |m: &mut HDNodeType| { &mut m.depth },
2239 ));
2240 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2241 "fingerprint",
2242 |m: &HDNodeType| { &m.fingerprint },
2243 |m: &mut HDNodeType| { &mut m.fingerprint },
2244 ));
2245 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2246 "child_num",
2247 |m: &HDNodeType| { &m.child_num },
2248 |m: &mut HDNodeType| { &mut m.child_num },
2249 ));
2250 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2251 "chain_code",
2252 |m: &HDNodeType| { &m.chain_code },
2253 |m: &mut HDNodeType| { &mut m.chain_code },
2254 ));
2255 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2256 "private_key",
2257 |m: &HDNodeType| { &m.private_key },
2258 |m: &mut HDNodeType| { &mut m.private_key },
2259 ));
2260 fields.push(::protobuf::reflect::rt::v2::make_option_accessor::<_, _>(
2261 "public_key",
2262 |m: &HDNodeType| { &m.public_key },
2263 |m: &mut HDNodeType| { &mut m.public_key },
2264 ));
2265 ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<HDNodeType>(
2266 "HDNodeType",
2267 fields,
2268 oneofs,
2269 )
2270 }
2271}
2272
2273impl ::protobuf::Message for HDNodeType {
2274 const NAME: &'static str = "HDNodeType";
2275
2276 fn is_initialized(&self) -> bool {
2277 if self.depth.is_none() {
2278 return false;
2279 }
2280 if self.fingerprint.is_none() {
2281 return false;
2282 }
2283 if self.child_num.is_none() {
2284 return false;
2285 }
2286 if self.chain_code.is_none() {
2287 return false;
2288 }
2289 if self.public_key.is_none() {
2290 return false;
2291 }
2292 true
2293 }
2294
2295 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::Result<()> {
2296 while let Some(tag) = is.read_raw_tag_or_eof()? {
2297 match tag {
2298 8 => {
2299 self.depth = ::std::option::Option::Some(is.read_uint32()?);
2300 },
2301 16 => {
2302 self.fingerprint = ::std::option::Option::Some(is.read_uint32()?);
2303 },
2304 24 => {
2305 self.child_num = ::std::option::Option::Some(is.read_uint32()?);
2306 },
2307 34 => {
2308 self.chain_code = ::std::option::Option::Some(is.read_bytes()?);
2309 },
2310 42 => {
2311 self.private_key = ::std::option::Option::Some(is.read_bytes()?);
2312 },
2313 50 => {
2314 self.public_key = ::std::option::Option::Some(is.read_bytes()?);
2315 },
2316 tag => {
2317 ::protobuf::rt::read_unknown_or_skip_group(tag, is, self.special_fields.mut_unknown_fields())?;
2318 },
2319 };
2320 }
2321 ::std::result::Result::Ok(())
2322 }
2323
2324 #[allow(unused_variables)]
2326 fn compute_size(&self) -> u64 {
2327 let mut my_size = 0;
2328 if let Some(v) = self.depth {
2329 my_size += ::protobuf::rt::uint32_size(1, v);
2330 }
2331 if let Some(v) = self.fingerprint {
2332 my_size += ::protobuf::rt::uint32_size(2, v);
2333 }
2334 if let Some(v) = self.child_num {
2335 my_size += ::protobuf::rt::uint32_size(3, v);
2336 }
2337 if let Some(v) = self.chain_code.as_ref() {
2338 my_size += ::protobuf::rt::bytes_size(4, &v);
2339 }
2340 if let Some(v) = self.private_key.as_ref() {
2341 my_size += ::protobuf::rt::bytes_size(5, &v);
2342 }
2343 if let Some(v) = self.public_key.as_ref() {
2344 my_size += ::protobuf::rt::bytes_size(6, &v);
2345 }
2346 my_size += ::protobuf::rt::unknown_fields_size(self.special_fields.unknown_fields());
2347 self.special_fields.cached_size().set(my_size as u32);
2348 my_size
2349 }
2350
2351 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::Result<()> {
2352 if let Some(v) = self.depth {
2353 os.write_uint32(1, v)?;
2354 }
2355 if let Some(v) = self.fingerprint {
2356 os.write_uint32(2, v)?;
2357 }
2358 if let Some(v) = self.child_num {
2359 os.write_uint32(3, v)?;
2360 }
2361 if let Some(v) = self.chain_code.as_ref() {
2362 os.write_bytes(4, v)?;
2363 }
2364 if let Some(v) = self.private_key.as_ref() {
2365 os.write_bytes(5, v)?;
2366 }
2367 if let Some(v) = self.public_key.as_ref() {
2368 os.write_bytes(6, v)?;
2369 }
2370 os.write_unknown_fields(self.special_fields.unknown_fields())?;
2371 ::std::result::Result::Ok(())
2372 }
2373
2374 fn special_fields(&self) -> &::protobuf::SpecialFields {
2375 &self.special_fields
2376 }
2377
2378 fn mut_special_fields(&mut self) -> &mut ::protobuf::SpecialFields {
2379 &mut self.special_fields
2380 }
2381
2382 fn new() -> HDNodeType {
2383 HDNodeType::new()
2384 }
2385
2386 fn clear(&mut self) {
2387 self.depth = ::std::option::Option::None;
2388 self.fingerprint = ::std::option::Option::None;
2389 self.child_num = ::std::option::Option::None;
2390 self.chain_code = ::std::option::Option::None;
2391 self.private_key = ::std::option::Option::None;
2392 self.public_key = ::std::option::Option::None;
2393 self.special_fields.clear();
2394 }
2395
2396 fn default_instance() -> &'static HDNodeType {
2397 static instance: HDNodeType = HDNodeType {
2398 depth: ::std::option::Option::None,
2399 fingerprint: ::std::option::Option::None,
2400 child_num: ::std::option::Option::None,
2401 chain_code: ::std::option::Option::None,
2402 private_key: ::std::option::Option::None,
2403 public_key: ::std::option::Option::None,
2404 special_fields: ::protobuf::SpecialFields::new(),
2405 };
2406 &instance
2407 }
2408}
2409
2410impl ::protobuf::MessageFull for HDNodeType {
2411 fn descriptor() -> ::protobuf::reflect::MessageDescriptor {
2412 static descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::Lazy::new();
2413 descriptor.get(|| file_descriptor().message_by_package_relative_name("HDNodeType").unwrap()).clone()
2414 }
2415}
2416
2417impl ::std::fmt::Display for HDNodeType {
2418 fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
2419 ::protobuf::text_format::fmt(self, f)
2420 }
2421}
2422
2423impl ::protobuf::reflect::ProtobufValue for HDNodeType {
2424 type RuntimeType = ::protobuf::reflect::rt::RuntimeTypeMessage<Self>;
2425}
2426
2427static file_descriptor_proto_data: &'static [u8] = b"\
2428 \n\x15messages-common.proto\x12\x19hw.trezor.messages.common\x1a\x0emess\
2429 ages.proto\"%\n\x07Success\x12\x1a\n\x07message\x18\x01\x20\x01(\t:\0R\
2430 \x07message\"\x8f\x04\n\x07Failure\x12B\n\x04code\x18\x01\x20\x01(\x0e2.\
2431 .hw.trezor.messages.common.Failure.FailureTypeR\x04code\x12\x18\n\x07mes\
2432 sage\x18\x02\x20\x01(\tR\x07message\"\xa5\x03\n\x0bFailureType\x12\x1d\n\
2433 \x19Failure_UnexpectedMessage\x10\x01\x12\x1a\n\x16Failure_ButtonExpecte\
2434 d\x10\x02\x12\x15\n\x11Failure_DataError\x10\x03\x12\x1b\n\x17Failure_Ac\
2435 tionCancelled\x10\x04\x12\x17\n\x13Failure_PinExpected\x10\x05\x12\x18\n\
2436 \x14Failure_PinCancelled\x10\x06\x12\x16\n\x12Failure_PinInvalid\x10\x07\
2437 \x12\x1c\n\x18Failure_InvalidSignature\x10\x08\x12\x18\n\x14Failure_Proc\
2438 essError\x10\t\x12\x1a\n\x16Failure_NotEnoughFunds\x10\n\x12\x1a\n\x16Fa\
2439 ilure_NotInitialized\x10\x0b\x12\x17\n\x13Failure_PinMismatch\x10\x0c\
2440 \x12\x1c\n\x18Failure_WipeCodeMismatch\x10\r\x12\x1a\n\x16Failure_Invali\
2441 dSession\x10\x0e\x12\x19\n\x15Failure_FirmwareError\x10c\"\x91\x06\n\rBu\
2442 ttonRequest\x12N\n\x04code\x18\x01\x20\x01(\x0e2:.hw.trezor.messages.com\
2443 mon.ButtonRequest.ButtonRequestTypeR\x04code\x12\x14\n\x05pages\x18\x02\
2444 \x20\x01(\rR\x05pages\"\x99\x05\n\x11ButtonRequestType\x12\x17\n\x13Butt\
2445 onRequest_Other\x10\x01\x12\"\n\x1eButtonRequest_FeeOverThreshold\x10\
2446 \x02\x12\x1f\n\x1bButtonRequest_ConfirmOutput\x10\x03\x12\x1d\n\x19Butto\
2447 nRequest_ResetDevice\x10\x04\x12\x1d\n\x19ButtonRequest_ConfirmWord\x10\
2448 \x05\x12\x1c\n\x18ButtonRequest_WipeDevice\x10\x06\x12\x1d\n\x19ButtonRe\
2449 quest_ProtectCall\x10\x07\x12\x18\n\x14ButtonRequest_SignTx\x10\x08\x12\
2450 \x1f\n\x1bButtonRequest_FirmwareCheck\x10\t\x12\x19\n\x15ButtonRequest_A\
2451 ddress\x10\n\x12\x1b\n\x17ButtonRequest_PublicKey\x10\x0b\x12#\n\x1fButt\
2452 onRequest_MnemonicWordCount\x10\x0c\x12\x1f\n\x1bButtonRequest_MnemonicI\
2453 nput\x10\r\x120\n(_Deprecated_ButtonRequest_PassphraseType\x10\x0e\x1a\
2454 \x02\x08\x01\x12'\n#ButtonRequest_UnknownDerivationPath\x10\x0f\x12\"\n\
2455 \x1eButtonRequest_RecoveryHomepage\x10\x10\x12\x19\n\x15ButtonRequest_Su\
2456 ccess\x10\x11\x12\x19\n\x15ButtonRequest_Warning\x10\x12\x12!\n\x1dButto\
2457 nRequest_PassphraseEntry\x10\x13\x12\x1a\n\x16ButtonRequest_PinEntry\x10\
2458 \x14\"\x0b\n\tButtonAck\"\xbb\x02\n\x10PinMatrixRequest\x12T\n\x04type\
2459 \x18\x01\x20\x01(\x0e2@.hw.trezor.messages.common.PinMatrixRequest.PinMa\
2460 trixRequestTypeR\x04type\"\xd0\x01\n\x14PinMatrixRequestType\x12\x20\n\
2461 \x1cPinMatrixRequestType_Current\x10\x01\x12!\n\x1dPinMatrixRequestType_\
2462 NewFirst\x10\x02\x12\"\n\x1ePinMatrixRequestType_NewSecond\x10\x03\x12&\
2463 \n\"PinMatrixRequestType_WipeCodeFirst\x10\x04\x12'\n#PinMatrixRequestTy\
2464 pe_WipeCodeSecond\x10\x05\"\x20\n\x0cPinMatrixAck\x12\x10\n\x03pin\x18\
2465 \x01\x20\x02(\tR\x03pin\"5\n\x11PassphraseRequest\x12\x20\n\n_on_device\
2466 \x18\x01\x20\x01(\x08R\x08OnDeviceB\x02\x18\x01\"g\n\rPassphraseAck\x12\
2467 \x1e\n\npassphrase\x18\x01\x20\x01(\tR\npassphrase\x12\x19\n\x06_state\
2468 \x18\x02\x20\x01(\x0cR\x05StateB\x02\x18\x01\x12\x1b\n\ton_device\x18\
2469 \x03\x20\x01(\x08R\x08onDevice\"=\n!Deprecated_PassphraseStateRequest\
2470 \x12\x14\n\x05state\x18\x01\x20\x01(\x0cR\x05state:\x02\x18\x01\"#\n\x1d\
2471 Deprecated_PassphraseStateAck:\x02\x18\x01\"\xc0\x01\n\nHDNodeType\x12\
2472 \x14\n\x05depth\x18\x01\x20\x02(\rR\x05depth\x12\x20\n\x0bfingerprint\
2473 \x18\x02\x20\x02(\rR\x0bfingerprint\x12\x1b\n\tchild_num\x18\x03\x20\x02\
2474 (\rR\x08childNum\x12\x1d\n\nchain_code\x18\x04\x20\x02(\x0cR\tchainCode\
2475 \x12\x1f\n\x0bprivate_key\x18\x05\x20\x01(\x0cR\nprivateKey\x12\x1d\n\np\
2476 ublic_key\x18\x06\x20\x02(\x0cR\tpublicKeyB>\n#com.satoshilabs.trezor.li\
2477 b.protobufB\x13TrezorMessageCommon\x80\xa6\x1d\x01\
2478";
2479
2480fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
2482 static file_descriptor_proto_lazy: ::protobuf::rt::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::Lazy::new();
2483 file_descriptor_proto_lazy.get(|| {
2484 ::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
2485 })
2486}
2487
2488pub fn file_descriptor() -> &'static ::protobuf::reflect::FileDescriptor {
2490 static generated_file_descriptor_lazy: ::protobuf::rt::Lazy<::protobuf::reflect::GeneratedFileDescriptor> = ::protobuf::rt::Lazy::new();
2491 static file_descriptor: ::protobuf::rt::Lazy<::protobuf::reflect::FileDescriptor> = ::protobuf::rt::Lazy::new();
2492 file_descriptor.get(|| {
2493 let generated_file_descriptor = generated_file_descriptor_lazy.get(|| {
2494 let mut deps = ::std::vec::Vec::with_capacity(1);
2495 deps.push(super::messages::file_descriptor().clone());
2496 let mut messages = ::std::vec::Vec::with_capacity(11);
2497 messages.push(Success::generated_message_descriptor_data());
2498 messages.push(Failure::generated_message_descriptor_data());
2499 messages.push(ButtonRequest::generated_message_descriptor_data());
2500 messages.push(ButtonAck::generated_message_descriptor_data());
2501 messages.push(PinMatrixRequest::generated_message_descriptor_data());
2502 messages.push(PinMatrixAck::generated_message_descriptor_data());
2503 messages.push(PassphraseRequest::generated_message_descriptor_data());
2504 messages.push(PassphraseAck::generated_message_descriptor_data());
2505 messages.push(Deprecated_PassphraseStateRequest::generated_message_descriptor_data());
2506 messages.push(Deprecated_PassphraseStateAck::generated_message_descriptor_data());
2507 messages.push(HDNodeType::generated_message_descriptor_data());
2508 let mut enums = ::std::vec::Vec::with_capacity(3);
2509 enums.push(failure::FailureType::generated_enum_descriptor_data());
2510 enums.push(button_request::ButtonRequestType::generated_enum_descriptor_data());
2511 enums.push(pin_matrix_request::PinMatrixRequestType::generated_enum_descriptor_data());
2512 ::protobuf::reflect::GeneratedFileDescriptor::new_generated(
2513 file_descriptor_proto(),
2514 deps,
2515 messages,
2516 enums,
2517 )
2518 });
2519 ::protobuf::reflect::FileDescriptor::new_generated_2(generated_file_descriptor)
2520 })
2521}