fidl_fuchsia_bluetooth_map__common/
fidl_fuchsia_bluetooth_map__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const CONVERSATION_ID_LENGTH: u8 = 16;
12
13pub const MAX_FOLDER_LENGTH: u16 = 512;
14
15pub const MAX_NUM_MAS_INSTANCE_LENGTH: u16 = 256;
16
17pub const MAX_SENDER_ADDR_LENGTH: u16 = 256;
18
19pub const MAX_SENDER_NAME_LENGTH: u16 = 256;
20
21pub const MAX_SUBJECT_LENGTH: u16 = 256;
22
23bitflags! {
24    /// Used to represent the type of a particular Message.
25    /// Also used to present the message types that are supported
26    /// by a Message Access Server.
27    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
28    pub struct MessageType: u8 {
29        const EMAIL = 1;
30        const SMS_GSM = 2;
31        const SMS_CDMA = 4;
32        const MMS = 8;
33        const IM = 16;
34    }
35}
36
37impl MessageType {
38    #[inline(always)]
39    pub fn from_bits_allow_unknown(bits: u8) -> Self {
40        Self::from_bits_retain(bits)
41    }
42
43    #[inline(always)]
44    pub fn has_unknown_bits(&self) -> bool {
45        self.get_unknown_bits() != 0
46    }
47
48    #[inline(always)]
49    pub fn get_unknown_bits(&self) -> u8 {
50        self.bits() & !Self::all().bits()
51    }
52}
53
54/// Specific error that is returned for Message Access/Message Notification
55/// related requests.
56#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
57#[repr(u32)]
58pub enum Error {
59    /// An unknown error occurred that cannot be classified as one of the more specific statuses.
60    Unknown = 1,
61    /// Peer was disconnected.
62    PeerDisconnected = 2,
63    /// Requested object or entity was not found.
64    NotFound = 3,
65    /// Request was not recognized/ill-formatted or contained parameters that
66    /// were not acceptable to the peer.
67    BadRequest = 4,
68    /// Request was not implemented at the peer.
69    NotImplemented = 5,
70    /// Object to be handled was protected and access was not authorized.
71    Unauthorized = 6,
72    /// Request could not be performed due to some condition at the peer.
73    Unavailable = 7,
74    /// The functionality is not supported by the peer.
75    NotSupported = 8,
76}
77
78impl Error {
79    #[inline]
80    pub fn from_primitive(prim: u32) -> Option<Self> {
81        match prim {
82            1 => Some(Self::Unknown),
83            2 => Some(Self::PeerDisconnected),
84            3 => Some(Self::NotFound),
85            4 => Some(Self::BadRequest),
86            5 => Some(Self::NotImplemented),
87            6 => Some(Self::Unauthorized),
88            7 => Some(Self::Unavailable),
89            8 => Some(Self::NotSupported),
90            _ => None,
91        }
92    }
93
94    #[inline]
95    pub const fn into_primitive(self) -> u32 {
96        self as u32
97    }
98}
99
100/// Notification type based on types defined in MAP v1.4.2 section 3.1.7.
101/// Note that MEMORY_FULL and MEMORY_AVAILABLE types are not represented as
102/// part of implementation decision.
103#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
104pub enum NotificationType {
105    NewMessage,
106    DeliverySuccess,
107    SendingSuccess,
108    DeliveryFailure,
109    SendingFailure,
110    MessageDeleted,
111    MessageShift,
112    ReadStatusChanged,
113    #[doc(hidden)]
114    __SourceBreaking {
115        unknown_ordinal: u32,
116    },
117}
118
119/// Pattern that matches an unknown `NotificationType` member.
120#[macro_export]
121macro_rules! NotificationTypeUnknown {
122    () => {
123        _
124    };
125}
126
127impl NotificationType {
128    #[inline]
129    pub fn from_primitive(prim: u32) -> Option<Self> {
130        match prim {
131            1 => Some(Self::NewMessage),
132            2 => Some(Self::DeliverySuccess),
133            3 => Some(Self::SendingSuccess),
134            4 => Some(Self::DeliveryFailure),
135            5 => Some(Self::SendingFailure),
136            6 => Some(Self::MessageDeleted),
137            7 => Some(Self::MessageShift),
138            8 => Some(Self::ReadStatusChanged),
139            _ => None,
140        }
141    }
142
143    #[inline]
144    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
145        match prim {
146            1 => Self::NewMessage,
147            2 => Self::DeliverySuccess,
148            3 => Self::SendingSuccess,
149            4 => Self::DeliveryFailure,
150            5 => Self::SendingFailure,
151            6 => Self::MessageDeleted,
152            7 => Self::MessageShift,
153            8 => Self::ReadStatusChanged,
154            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
155        }
156    }
157
158    #[inline]
159    pub fn unknown() -> Self {
160        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
161    }
162
163    #[inline]
164    pub const fn into_primitive(self) -> u32 {
165        match self {
166            Self::NewMessage => 1,
167            Self::DeliverySuccess => 2,
168            Self::SendingSuccess => 3,
169            Self::DeliveryFailure => 4,
170            Self::SendingFailure => 5,
171            Self::MessageDeleted => 6,
172            Self::MessageShift => 7,
173            Self::ReadStatusChanged => 8,
174            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
175        }
176    }
177
178    #[inline]
179    pub fn is_unknown(&self) -> bool {
180        match self {
181            Self::__SourceBreaking { unknown_ordinal: _ } => true,
182            _ => false,
183        }
184    }
185}
186
187#[derive(Clone, Debug, PartialEq)]
188pub struct AccessorListAllMasInstancesResponse {
189    pub instances: Vec<MasInstance>,
190}
191
192impl fidl::Persistable for AccessorListAllMasInstancesResponse {}
193
194#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
195pub struct MessageControllerGetDetailsRequest {
196    pub handle: u64,
197    pub include_attachment: bool,
198}
199
200impl fidl::Persistable for MessageControllerGetDetailsRequest {}
201
202#[derive(Clone, Debug, Default, PartialEq)]
203pub struct Audience {
204    /// Addressing information. In the case of emails, it's email address.
205    /// In the case of an email, this is the sender's email address.
206    /// In the case of an SMS, this is the sender's phone number.
207    /// In the case of an MMS, this is the senders email address or phone number.
208    pub addressing: Option<String>,
209    /// Display friendly name.
210    pub name: Option<String>,
211    #[doc(hidden)]
212    pub __source_breaking: fidl::marker::SourceBreaking,
213}
214
215impl fidl::Persistable for Audience {}
216
217/// Represents a Message Access Service Instance as described in
218/// MAP v1.4.2 section 3.1.8.
219#[derive(Clone, Debug, Default, PartialEq)]
220pub struct MasInstance {
221    pub id: Option<u8>,
222    pub supported_message_types: Option<MessageType>,
223    pub supports_notification: Option<bool>,
224    #[doc(hidden)]
225    pub __source_breaking: fidl::marker::SourceBreaking,
226}
227
228impl fidl::Persistable for MasInstance {}
229
230/// Based on x-bt/message, x-bt/MAP-msg-listing v1.1, and MAP-Event-Report NewMessage objects.
231/// See MAP v1.4.2 sections 3.1.3 and 3.1.6 for details.
232/// Depending on the method used to get the message, not all fields
233/// may be populated.
234#[derive(Clone, Debug, Default, PartialEq)]
235pub struct Message {
236    /// Handle for this message. Locally unique to each
237    /// Message Server Equipment (MSE).
238    /// Always present.
239    pub handle: Option<u64>,
240    /// Summary of the message.
241    pub subject: Option<String>,
242    /// Unix timestamp that represents the sending time if it was included
243    /// in the message, otherwise represents the reception time of the MSE.
244    pub timestamp: Option<i64>,
245    /// Information about the sender.
246    pub sender: Option<Audience>,
247    /// Information about the recipient.
248    pub recipient: Option<Audience>,
249    /// Type of the message.
250    /// Always present.
251    pub type_: Option<MessageType>,
252    /// Content of the message.
253    pub content: Option<String>,
254    /// Folder where the message is located in.
255    pub folder: Option<String>,
256    /// Whether or not message is high priority.
257    /// If this information is missing, it would be set as unknown, not false.
258    pub priority: Option<bool>,
259    /// Whether or not message was read.
260    /// If this information is missing, it would be set as unknown, not false.
261    pub read: Option<bool>,
262    /// Whether or not meessage has already been sent to the recipient.
263    /// If this information is missing, it would be set as unknown, not false.
264    pub sent: Option<bool>,
265    /// Whether or not message is protected by a DRM scheme.
266    pub protected: Option<bool>,
267    /// A 128 bit value that uniquely identifies a conversation within a single MAS instance.
268    pub conversation_id: Option<[u8; 16]>,
269    #[doc(hidden)]
270    pub __source_breaking: fidl::marker::SourceBreaking,
271}
272
273impl fidl::Persistable for Message {}
274
275/// Notification data from incoming event report from a remote MSE device.
276/// See MAP v1.4.2 section 3.1.7 for details about MAP event report objects.
277/// Note that not all fields are represented.
278#[derive(Clone, Debug, Default, PartialEq)]
279pub struct Notification {
280    pub type_: Option<NotificationType>,
281    pub mas_instance_id: Option<u8>,
282    pub message_handle: Option<u64>,
283    pub folder: Option<String>,
284    pub message_type: Option<MessageType>,
285    pub timestamp: Option<i64>,
286    pub subject: Option<String>,
287    pub sender: Option<Audience>,
288    pub priority: Option<bool>,
289    #[doc(hidden)]
290    pub __source_breaking: fidl::marker::SourceBreaking,
291}
292
293impl fidl::Persistable for Notification {}
294
295#[derive(Clone, Debug, Default, PartialEq)]
296pub struct NotificationRegistrationNewEventReportRequest {
297    pub notification: Option<Notification>,
298    pub received: Option<i64>,
299    #[doc(hidden)]
300    pub __source_breaking: fidl::marker::SourceBreaking,
301}
302
303impl fidl::Persistable for NotificationRegistrationNewEventReportRequest {}
304
305mod internal {
306    use super::*;
307    unsafe impl fidl::encoding::TypeMarker for MessageType {
308        type Owned = Self;
309
310        #[inline(always)]
311        fn inline_align(_context: fidl::encoding::Context) -> usize {
312            1
313        }
314
315        #[inline(always)]
316        fn inline_size(_context: fidl::encoding::Context) -> usize {
317            1
318        }
319    }
320
321    impl fidl::encoding::ValueTypeMarker for MessageType {
322        type Borrowed<'a> = Self;
323        #[inline(always)]
324        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
325            *value
326        }
327    }
328
329    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
330        #[inline]
331        unsafe fn encode(
332            self,
333            encoder: &mut fidl::encoding::Encoder<'_, D>,
334            offset: usize,
335            _depth: fidl::encoding::Depth,
336        ) -> fidl::Result<()> {
337            encoder.debug_check_bounds::<Self>(offset);
338            encoder.write_num(self.bits(), offset);
339            Ok(())
340        }
341    }
342
343    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
344        #[inline(always)]
345        fn new_empty() -> Self {
346            Self::empty()
347        }
348
349        #[inline]
350        unsafe fn decode(
351            &mut self,
352            decoder: &mut fidl::encoding::Decoder<'_, D>,
353            offset: usize,
354            _depth: fidl::encoding::Depth,
355        ) -> fidl::Result<()> {
356            decoder.debug_check_bounds::<Self>(offset);
357            let prim = decoder.read_num::<u8>(offset);
358            *self = Self::from_bits_allow_unknown(prim);
359            Ok(())
360        }
361    }
362    unsafe impl fidl::encoding::TypeMarker for Error {
363        type Owned = Self;
364
365        #[inline(always)]
366        fn inline_align(_context: fidl::encoding::Context) -> usize {
367            std::mem::align_of::<u32>()
368        }
369
370        #[inline(always)]
371        fn inline_size(_context: fidl::encoding::Context) -> usize {
372            std::mem::size_of::<u32>()
373        }
374
375        #[inline(always)]
376        fn encode_is_copy() -> bool {
377            true
378        }
379
380        #[inline(always)]
381        fn decode_is_copy() -> bool {
382            false
383        }
384    }
385
386    impl fidl::encoding::ValueTypeMarker for Error {
387        type Borrowed<'a> = Self;
388        #[inline(always)]
389        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
390            *value
391        }
392    }
393
394    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
395        #[inline]
396        unsafe fn encode(
397            self,
398            encoder: &mut fidl::encoding::Encoder<'_, D>,
399            offset: usize,
400            _depth: fidl::encoding::Depth,
401        ) -> fidl::Result<()> {
402            encoder.debug_check_bounds::<Self>(offset);
403            encoder.write_num(self.into_primitive(), offset);
404            Ok(())
405        }
406    }
407
408    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
409        #[inline(always)]
410        fn new_empty() -> Self {
411            Self::Unknown
412        }
413
414        #[inline]
415        unsafe fn decode(
416            &mut self,
417            decoder: &mut fidl::encoding::Decoder<'_, D>,
418            offset: usize,
419            _depth: fidl::encoding::Depth,
420        ) -> fidl::Result<()> {
421            decoder.debug_check_bounds::<Self>(offset);
422            let prim = decoder.read_num::<u32>(offset);
423
424            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
425            Ok(())
426        }
427    }
428    unsafe impl fidl::encoding::TypeMarker for NotificationType {
429        type Owned = Self;
430
431        #[inline(always)]
432        fn inline_align(_context: fidl::encoding::Context) -> usize {
433            std::mem::align_of::<u32>()
434        }
435
436        #[inline(always)]
437        fn inline_size(_context: fidl::encoding::Context) -> usize {
438            std::mem::size_of::<u32>()
439        }
440
441        #[inline(always)]
442        fn encode_is_copy() -> bool {
443            false
444        }
445
446        #[inline(always)]
447        fn decode_is_copy() -> bool {
448            false
449        }
450    }
451
452    impl fidl::encoding::ValueTypeMarker for NotificationType {
453        type Borrowed<'a> = Self;
454        #[inline(always)]
455        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
456            *value
457        }
458    }
459
460    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
461        for NotificationType
462    {
463        #[inline]
464        unsafe fn encode(
465            self,
466            encoder: &mut fidl::encoding::Encoder<'_, D>,
467            offset: usize,
468            _depth: fidl::encoding::Depth,
469        ) -> fidl::Result<()> {
470            encoder.debug_check_bounds::<Self>(offset);
471            encoder.write_num(self.into_primitive(), offset);
472            Ok(())
473        }
474    }
475
476    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NotificationType {
477        #[inline(always)]
478        fn new_empty() -> Self {
479            Self::unknown()
480        }
481
482        #[inline]
483        unsafe fn decode(
484            &mut self,
485            decoder: &mut fidl::encoding::Decoder<'_, D>,
486            offset: usize,
487            _depth: fidl::encoding::Depth,
488        ) -> fidl::Result<()> {
489            decoder.debug_check_bounds::<Self>(offset);
490            let prim = decoder.read_num::<u32>(offset);
491
492            *self = Self::from_primitive_allow_unknown(prim);
493            Ok(())
494        }
495    }
496
497    impl fidl::encoding::ValueTypeMarker for AccessorListAllMasInstancesResponse {
498        type Borrowed<'a> = &'a Self;
499        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
500            value
501        }
502    }
503
504    unsafe impl fidl::encoding::TypeMarker for AccessorListAllMasInstancesResponse {
505        type Owned = Self;
506
507        #[inline(always)]
508        fn inline_align(_context: fidl::encoding::Context) -> usize {
509            8
510        }
511
512        #[inline(always)]
513        fn inline_size(_context: fidl::encoding::Context) -> usize {
514            16
515        }
516    }
517
518    unsafe impl<D: fidl::encoding::ResourceDialect>
519        fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D>
520        for &AccessorListAllMasInstancesResponse
521    {
522        #[inline]
523        unsafe fn encode(
524            self,
525            encoder: &mut fidl::encoding::Encoder<'_, D>,
526            offset: usize,
527            _depth: fidl::encoding::Depth,
528        ) -> fidl::Result<()> {
529            encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
530            // Delegate to tuple encoding.
531            fidl::encoding::Encode::<AccessorListAllMasInstancesResponse, D>::encode(
532                (
533                    <fidl::encoding::Vector<MasInstance, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.instances),
534                ),
535                encoder, offset, _depth
536            )
537        }
538    }
539    unsafe impl<
540            D: fidl::encoding::ResourceDialect,
541            T0: fidl::encoding::Encode<fidl::encoding::Vector<MasInstance, 256>, D>,
542        > fidl::encoding::Encode<AccessorListAllMasInstancesResponse, D> for (T0,)
543    {
544        #[inline]
545        unsafe fn encode(
546            self,
547            encoder: &mut fidl::encoding::Encoder<'_, D>,
548            offset: usize,
549            depth: fidl::encoding::Depth,
550        ) -> fidl::Result<()> {
551            encoder.debug_check_bounds::<AccessorListAllMasInstancesResponse>(offset);
552            // Zero out padding regions. There's no need to apply masks
553            // because the unmasked parts will be overwritten by fields.
554            // Write the fields.
555            self.0.encode(encoder, offset + 0, depth)?;
556            Ok(())
557        }
558    }
559
560    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
561        for AccessorListAllMasInstancesResponse
562    {
563        #[inline(always)]
564        fn new_empty() -> Self {
565            Self { instances: fidl::new_empty!(fidl::encoding::Vector<MasInstance, 256>, D) }
566        }
567
568        #[inline]
569        unsafe fn decode(
570            &mut self,
571            decoder: &mut fidl::encoding::Decoder<'_, D>,
572            offset: usize,
573            _depth: fidl::encoding::Depth,
574        ) -> fidl::Result<()> {
575            decoder.debug_check_bounds::<Self>(offset);
576            // Verify that padding bytes are zero.
577            fidl::decode!(fidl::encoding::Vector<MasInstance, 256>, D, &mut self.instances, decoder, offset + 0, _depth)?;
578            Ok(())
579        }
580    }
581
582    impl fidl::encoding::ValueTypeMarker for MessageControllerGetDetailsRequest {
583        type Borrowed<'a> = &'a Self;
584        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
585            value
586        }
587    }
588
589    unsafe impl fidl::encoding::TypeMarker for MessageControllerGetDetailsRequest {
590        type Owned = Self;
591
592        #[inline(always)]
593        fn inline_align(_context: fidl::encoding::Context) -> usize {
594            8
595        }
596
597        #[inline(always)]
598        fn inline_size(_context: fidl::encoding::Context) -> usize {
599            16
600        }
601    }
602
603    unsafe impl<D: fidl::encoding::ResourceDialect>
604        fidl::encoding::Encode<MessageControllerGetDetailsRequest, D>
605        for &MessageControllerGetDetailsRequest
606    {
607        #[inline]
608        unsafe fn encode(
609            self,
610            encoder: &mut fidl::encoding::Encoder<'_, D>,
611            offset: usize,
612            _depth: fidl::encoding::Depth,
613        ) -> fidl::Result<()> {
614            encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
615            // Delegate to tuple encoding.
616            fidl::encoding::Encode::<MessageControllerGetDetailsRequest, D>::encode(
617                (
618                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.handle),
619                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.include_attachment),
620                ),
621                encoder,
622                offset,
623                _depth,
624            )
625        }
626    }
627    unsafe impl<
628            D: fidl::encoding::ResourceDialect,
629            T0: fidl::encoding::Encode<u64, D>,
630            T1: fidl::encoding::Encode<bool, D>,
631        > fidl::encoding::Encode<MessageControllerGetDetailsRequest, D> for (T0, T1)
632    {
633        #[inline]
634        unsafe fn encode(
635            self,
636            encoder: &mut fidl::encoding::Encoder<'_, D>,
637            offset: usize,
638            depth: fidl::encoding::Depth,
639        ) -> fidl::Result<()> {
640            encoder.debug_check_bounds::<MessageControllerGetDetailsRequest>(offset);
641            // Zero out padding regions. There's no need to apply masks
642            // because the unmasked parts will be overwritten by fields.
643            unsafe {
644                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
645                (ptr as *mut u64).write_unaligned(0);
646            }
647            // Write the fields.
648            self.0.encode(encoder, offset + 0, depth)?;
649            self.1.encode(encoder, offset + 8, depth)?;
650            Ok(())
651        }
652    }
653
654    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
655        for MessageControllerGetDetailsRequest
656    {
657        #[inline(always)]
658        fn new_empty() -> Self {
659            Self { handle: fidl::new_empty!(u64, D), include_attachment: fidl::new_empty!(bool, D) }
660        }
661
662        #[inline]
663        unsafe fn decode(
664            &mut self,
665            decoder: &mut fidl::encoding::Decoder<'_, D>,
666            offset: usize,
667            _depth: fidl::encoding::Depth,
668        ) -> fidl::Result<()> {
669            decoder.debug_check_bounds::<Self>(offset);
670            // Verify that padding bytes are zero.
671            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
672            let padval = unsafe { (ptr as *const u64).read_unaligned() };
673            let mask = 0xffffffffffffff00u64;
674            let maskedval = padval & mask;
675            if maskedval != 0 {
676                return Err(fidl::Error::NonZeroPadding {
677                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
678                });
679            }
680            fidl::decode!(u64, D, &mut self.handle, decoder, offset + 0, _depth)?;
681            fidl::decode!(bool, D, &mut self.include_attachment, decoder, offset + 8, _depth)?;
682            Ok(())
683        }
684    }
685
686    impl Audience {
687        #[inline(always)]
688        fn max_ordinal_present(&self) -> u64 {
689            if let Some(_) = self.name {
690                return 2;
691            }
692            if let Some(_) = self.addressing {
693                return 1;
694            }
695            0
696        }
697    }
698
699    impl fidl::encoding::ValueTypeMarker for Audience {
700        type Borrowed<'a> = &'a Self;
701        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
702            value
703        }
704    }
705
706    unsafe impl fidl::encoding::TypeMarker for Audience {
707        type Owned = Self;
708
709        #[inline(always)]
710        fn inline_align(_context: fidl::encoding::Context) -> usize {
711            8
712        }
713
714        #[inline(always)]
715        fn inline_size(_context: fidl::encoding::Context) -> usize {
716            16
717        }
718    }
719
720    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Audience, D> for &Audience {
721        unsafe fn encode(
722            self,
723            encoder: &mut fidl::encoding::Encoder<'_, D>,
724            offset: usize,
725            mut depth: fidl::encoding::Depth,
726        ) -> fidl::Result<()> {
727            encoder.debug_check_bounds::<Audience>(offset);
728            // Vector header
729            let max_ordinal: u64 = self.max_ordinal_present();
730            encoder.write_num(max_ordinal, offset);
731            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
732            // Calling encoder.out_of_line_offset(0) is not allowed.
733            if max_ordinal == 0 {
734                return Ok(());
735            }
736            depth.increment()?;
737            let envelope_size = 8;
738            let bytes_len = max_ordinal as usize * envelope_size;
739            #[allow(unused_variables)]
740            let offset = encoder.out_of_line_offset(bytes_len);
741            let mut _prev_end_offset: usize = 0;
742            if 1 > max_ordinal {
743                return Ok(());
744            }
745
746            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
747            // are envelope_size bytes.
748            let cur_offset: usize = (1 - 1) * envelope_size;
749
750            // Zero reserved fields.
751            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
752
753            // Safety:
754            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
755            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
756            //   envelope_size bytes, there is always sufficient room.
757            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
758                self.addressing.as_ref().map(
759                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
760                ),
761                encoder,
762                offset + cur_offset,
763                depth,
764            )?;
765
766            _prev_end_offset = cur_offset + envelope_size;
767            if 2 > max_ordinal {
768                return Ok(());
769            }
770
771            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
772            // are envelope_size bytes.
773            let cur_offset: usize = (2 - 1) * envelope_size;
774
775            // Zero reserved fields.
776            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
777
778            // Safety:
779            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
780            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
781            //   envelope_size bytes, there is always sufficient room.
782            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
783                self.name.as_ref().map(
784                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
785                ),
786                encoder,
787                offset + cur_offset,
788                depth,
789            )?;
790
791            _prev_end_offset = cur_offset + envelope_size;
792
793            Ok(())
794        }
795    }
796
797    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Audience {
798        #[inline(always)]
799        fn new_empty() -> Self {
800            Self::default()
801        }
802
803        unsafe fn decode(
804            &mut self,
805            decoder: &mut fidl::encoding::Decoder<'_, D>,
806            offset: usize,
807            mut depth: fidl::encoding::Depth,
808        ) -> fidl::Result<()> {
809            decoder.debug_check_bounds::<Self>(offset);
810            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
811                None => return Err(fidl::Error::NotNullable),
812                Some(len) => len,
813            };
814            // Calling decoder.out_of_line_offset(0) is not allowed.
815            if len == 0 {
816                return Ok(());
817            };
818            depth.increment()?;
819            let envelope_size = 8;
820            let bytes_len = len * envelope_size;
821            let offset = decoder.out_of_line_offset(bytes_len)?;
822            // Decode the envelope for each type.
823            let mut _next_ordinal_to_read = 0;
824            let mut next_offset = offset;
825            let end_offset = offset + bytes_len;
826            _next_ordinal_to_read += 1;
827            if next_offset >= end_offset {
828                return Ok(());
829            }
830
831            // Decode unknown envelopes for gaps in ordinals.
832            while _next_ordinal_to_read < 1 {
833                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
834                _next_ordinal_to_read += 1;
835                next_offset += envelope_size;
836            }
837
838            let next_out_of_line = decoder.next_out_of_line();
839            let handles_before = decoder.remaining_handles();
840            if let Some((inlined, num_bytes, num_handles)) =
841                fidl::encoding::decode_envelope_header(decoder, next_offset)?
842            {
843                let member_inline_size =
844                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
845                        decoder.context,
846                    );
847                if inlined != (member_inline_size <= 4) {
848                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
849                }
850                let inner_offset;
851                let mut inner_depth = depth.clone();
852                if inlined {
853                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
854                    inner_offset = next_offset;
855                } else {
856                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
857                    inner_depth.increment()?;
858                }
859                let val_ref = self
860                    .addressing
861                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
862                fidl::decode!(
863                    fidl::encoding::BoundedString<256>,
864                    D,
865                    val_ref,
866                    decoder,
867                    inner_offset,
868                    inner_depth
869                )?;
870                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
871                {
872                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
873                }
874                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
875                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
876                }
877            }
878
879            next_offset += envelope_size;
880            _next_ordinal_to_read += 1;
881            if next_offset >= end_offset {
882                return Ok(());
883            }
884
885            // Decode unknown envelopes for gaps in ordinals.
886            while _next_ordinal_to_read < 2 {
887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
888                _next_ordinal_to_read += 1;
889                next_offset += envelope_size;
890            }
891
892            let next_out_of_line = decoder.next_out_of_line();
893            let handles_before = decoder.remaining_handles();
894            if let Some((inlined, num_bytes, num_handles)) =
895                fidl::encoding::decode_envelope_header(decoder, next_offset)?
896            {
897                let member_inline_size =
898                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
899                        decoder.context,
900                    );
901                if inlined != (member_inline_size <= 4) {
902                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
903                }
904                let inner_offset;
905                let mut inner_depth = depth.clone();
906                if inlined {
907                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
908                    inner_offset = next_offset;
909                } else {
910                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
911                    inner_depth.increment()?;
912                }
913                let val_ref = self
914                    .name
915                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
916                fidl::decode!(
917                    fidl::encoding::BoundedString<256>,
918                    D,
919                    val_ref,
920                    decoder,
921                    inner_offset,
922                    inner_depth
923                )?;
924                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
925                {
926                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
927                }
928                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
929                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
930                }
931            }
932
933            next_offset += envelope_size;
934
935            // Decode the remaining unknown envelopes.
936            while next_offset < end_offset {
937                _next_ordinal_to_read += 1;
938                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
939                next_offset += envelope_size;
940            }
941
942            Ok(())
943        }
944    }
945
946    impl MasInstance {
947        #[inline(always)]
948        fn max_ordinal_present(&self) -> u64 {
949            if let Some(_) = self.supports_notification {
950                return 3;
951            }
952            if let Some(_) = self.supported_message_types {
953                return 2;
954            }
955            if let Some(_) = self.id {
956                return 1;
957            }
958            0
959        }
960    }
961
962    impl fidl::encoding::ValueTypeMarker for MasInstance {
963        type Borrowed<'a> = &'a Self;
964        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
965            value
966        }
967    }
968
969    unsafe impl fidl::encoding::TypeMarker for MasInstance {
970        type Owned = Self;
971
972        #[inline(always)]
973        fn inline_align(_context: fidl::encoding::Context) -> usize {
974            8
975        }
976
977        #[inline(always)]
978        fn inline_size(_context: fidl::encoding::Context) -> usize {
979            16
980        }
981    }
982
983    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MasInstance, D>
984        for &MasInstance
985    {
986        unsafe fn encode(
987            self,
988            encoder: &mut fidl::encoding::Encoder<'_, D>,
989            offset: usize,
990            mut depth: fidl::encoding::Depth,
991        ) -> fidl::Result<()> {
992            encoder.debug_check_bounds::<MasInstance>(offset);
993            // Vector header
994            let max_ordinal: u64 = self.max_ordinal_present();
995            encoder.write_num(max_ordinal, offset);
996            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
997            // Calling encoder.out_of_line_offset(0) is not allowed.
998            if max_ordinal == 0 {
999                return Ok(());
1000            }
1001            depth.increment()?;
1002            let envelope_size = 8;
1003            let bytes_len = max_ordinal as usize * envelope_size;
1004            #[allow(unused_variables)]
1005            let offset = encoder.out_of_line_offset(bytes_len);
1006            let mut _prev_end_offset: usize = 0;
1007            if 1 > max_ordinal {
1008                return Ok(());
1009            }
1010
1011            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1012            // are envelope_size bytes.
1013            let cur_offset: usize = (1 - 1) * envelope_size;
1014
1015            // Zero reserved fields.
1016            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1017
1018            // Safety:
1019            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1020            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1021            //   envelope_size bytes, there is always sufficient room.
1022            fidl::encoding::encode_in_envelope_optional::<u8, D>(
1023                self.id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
1024                encoder,
1025                offset + cur_offset,
1026                depth,
1027            )?;
1028
1029            _prev_end_offset = cur_offset + envelope_size;
1030            if 2 > max_ordinal {
1031                return Ok(());
1032            }
1033
1034            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1035            // are envelope_size bytes.
1036            let cur_offset: usize = (2 - 1) * envelope_size;
1037
1038            // Zero reserved fields.
1039            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1040
1041            // Safety:
1042            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1043            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1044            //   envelope_size bytes, there is always sufficient room.
1045            fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1046                self.supported_message_types
1047                    .as_ref()
1048                    .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1049                encoder,
1050                offset + cur_offset,
1051                depth,
1052            )?;
1053
1054            _prev_end_offset = cur_offset + envelope_size;
1055            if 3 > max_ordinal {
1056                return Ok(());
1057            }
1058
1059            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1060            // are envelope_size bytes.
1061            let cur_offset: usize = (3 - 1) * envelope_size;
1062
1063            // Zero reserved fields.
1064            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1065
1066            // Safety:
1067            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1068            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1069            //   envelope_size bytes, there is always sufficient room.
1070            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1071                self.supports_notification
1072                    .as_ref()
1073                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1074                encoder,
1075                offset + cur_offset,
1076                depth,
1077            )?;
1078
1079            _prev_end_offset = cur_offset + envelope_size;
1080
1081            Ok(())
1082        }
1083    }
1084
1085    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MasInstance {
1086        #[inline(always)]
1087        fn new_empty() -> Self {
1088            Self::default()
1089        }
1090
1091        unsafe fn decode(
1092            &mut self,
1093            decoder: &mut fidl::encoding::Decoder<'_, D>,
1094            offset: usize,
1095            mut depth: fidl::encoding::Depth,
1096        ) -> fidl::Result<()> {
1097            decoder.debug_check_bounds::<Self>(offset);
1098            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1099                None => return Err(fidl::Error::NotNullable),
1100                Some(len) => len,
1101            };
1102            // Calling decoder.out_of_line_offset(0) is not allowed.
1103            if len == 0 {
1104                return Ok(());
1105            };
1106            depth.increment()?;
1107            let envelope_size = 8;
1108            let bytes_len = len * envelope_size;
1109            let offset = decoder.out_of_line_offset(bytes_len)?;
1110            // Decode the envelope for each type.
1111            let mut _next_ordinal_to_read = 0;
1112            let mut next_offset = offset;
1113            let end_offset = offset + bytes_len;
1114            _next_ordinal_to_read += 1;
1115            if next_offset >= end_offset {
1116                return Ok(());
1117            }
1118
1119            // Decode unknown envelopes for gaps in ordinals.
1120            while _next_ordinal_to_read < 1 {
1121                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1122                _next_ordinal_to_read += 1;
1123                next_offset += envelope_size;
1124            }
1125
1126            let next_out_of_line = decoder.next_out_of_line();
1127            let handles_before = decoder.remaining_handles();
1128            if let Some((inlined, num_bytes, num_handles)) =
1129                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1130            {
1131                let member_inline_size =
1132                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1133                if inlined != (member_inline_size <= 4) {
1134                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1135                }
1136                let inner_offset;
1137                let mut inner_depth = depth.clone();
1138                if inlined {
1139                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1140                    inner_offset = next_offset;
1141                } else {
1142                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1143                    inner_depth.increment()?;
1144                }
1145                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u8, D));
1146                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
1147                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1148                {
1149                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1150                }
1151                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1152                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1153                }
1154            }
1155
1156            next_offset += envelope_size;
1157            _next_ordinal_to_read += 1;
1158            if next_offset >= end_offset {
1159                return Ok(());
1160            }
1161
1162            // Decode unknown envelopes for gaps in ordinals.
1163            while _next_ordinal_to_read < 2 {
1164                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1165                _next_ordinal_to_read += 1;
1166                next_offset += envelope_size;
1167            }
1168
1169            let next_out_of_line = decoder.next_out_of_line();
1170            let handles_before = decoder.remaining_handles();
1171            if let Some((inlined, num_bytes, num_handles)) =
1172                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1173            {
1174                let member_inline_size =
1175                    <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1176                if inlined != (member_inline_size <= 4) {
1177                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1178                }
1179                let inner_offset;
1180                let mut inner_depth = depth.clone();
1181                if inlined {
1182                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1183                    inner_offset = next_offset;
1184                } else {
1185                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1186                    inner_depth.increment()?;
1187                }
1188                let val_ref = self
1189                    .supported_message_types
1190                    .get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1191                fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1192                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1193                {
1194                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1195                }
1196                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1197                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1198                }
1199            }
1200
1201            next_offset += envelope_size;
1202            _next_ordinal_to_read += 1;
1203            if next_offset >= end_offset {
1204                return Ok(());
1205            }
1206
1207            // Decode unknown envelopes for gaps in ordinals.
1208            while _next_ordinal_to_read < 3 {
1209                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1210                _next_ordinal_to_read += 1;
1211                next_offset += envelope_size;
1212            }
1213
1214            let next_out_of_line = decoder.next_out_of_line();
1215            let handles_before = decoder.remaining_handles();
1216            if let Some((inlined, num_bytes, num_handles)) =
1217                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1218            {
1219                let member_inline_size =
1220                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1221                if inlined != (member_inline_size <= 4) {
1222                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1223                }
1224                let inner_offset;
1225                let mut inner_depth = depth.clone();
1226                if inlined {
1227                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1228                    inner_offset = next_offset;
1229                } else {
1230                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1231                    inner_depth.increment()?;
1232                }
1233                let val_ref =
1234                    self.supports_notification.get_or_insert_with(|| fidl::new_empty!(bool, D));
1235                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1236                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1237                {
1238                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1239                }
1240                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1241                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1242                }
1243            }
1244
1245            next_offset += envelope_size;
1246
1247            // Decode the remaining unknown envelopes.
1248            while next_offset < end_offset {
1249                _next_ordinal_to_read += 1;
1250                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1251                next_offset += envelope_size;
1252            }
1253
1254            Ok(())
1255        }
1256    }
1257
1258    impl Message {
1259        #[inline(always)]
1260        fn max_ordinal_present(&self) -> u64 {
1261            if let Some(_) = self.conversation_id {
1262                return 13;
1263            }
1264            if let Some(_) = self.protected {
1265                return 12;
1266            }
1267            if let Some(_) = self.sent {
1268                return 11;
1269            }
1270            if let Some(_) = self.read {
1271                return 10;
1272            }
1273            if let Some(_) = self.priority {
1274                return 9;
1275            }
1276            if let Some(_) = self.folder {
1277                return 8;
1278            }
1279            if let Some(_) = self.content {
1280                return 7;
1281            }
1282            if let Some(_) = self.type_ {
1283                return 6;
1284            }
1285            if let Some(_) = self.recipient {
1286                return 5;
1287            }
1288            if let Some(_) = self.sender {
1289                return 4;
1290            }
1291            if let Some(_) = self.timestamp {
1292                return 3;
1293            }
1294            if let Some(_) = self.subject {
1295                return 2;
1296            }
1297            if let Some(_) = self.handle {
1298                return 1;
1299            }
1300            0
1301        }
1302    }
1303
1304    impl fidl::encoding::ValueTypeMarker for Message {
1305        type Borrowed<'a> = &'a Self;
1306        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1307            value
1308        }
1309    }
1310
1311    unsafe impl fidl::encoding::TypeMarker for Message {
1312        type Owned = Self;
1313
1314        #[inline(always)]
1315        fn inline_align(_context: fidl::encoding::Context) -> usize {
1316            8
1317        }
1318
1319        #[inline(always)]
1320        fn inline_size(_context: fidl::encoding::Context) -> usize {
1321            16
1322        }
1323    }
1324
1325    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Message, D> for &Message {
1326        unsafe fn encode(
1327            self,
1328            encoder: &mut fidl::encoding::Encoder<'_, D>,
1329            offset: usize,
1330            mut depth: fidl::encoding::Depth,
1331        ) -> fidl::Result<()> {
1332            encoder.debug_check_bounds::<Message>(offset);
1333            // Vector header
1334            let max_ordinal: u64 = self.max_ordinal_present();
1335            encoder.write_num(max_ordinal, offset);
1336            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1337            // Calling encoder.out_of_line_offset(0) is not allowed.
1338            if max_ordinal == 0 {
1339                return Ok(());
1340            }
1341            depth.increment()?;
1342            let envelope_size = 8;
1343            let bytes_len = max_ordinal as usize * envelope_size;
1344            #[allow(unused_variables)]
1345            let offset = encoder.out_of_line_offset(bytes_len);
1346            let mut _prev_end_offset: usize = 0;
1347            if 1 > max_ordinal {
1348                return Ok(());
1349            }
1350
1351            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1352            // are envelope_size bytes.
1353            let cur_offset: usize = (1 - 1) * envelope_size;
1354
1355            // Zero reserved fields.
1356            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1357
1358            // Safety:
1359            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1360            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1361            //   envelope_size bytes, there is always sufficient room.
1362            fidl::encoding::encode_in_envelope_optional::<u64, D>(
1363                self.handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1364                encoder,
1365                offset + cur_offset,
1366                depth,
1367            )?;
1368
1369            _prev_end_offset = cur_offset + envelope_size;
1370            if 2 > max_ordinal {
1371                return Ok(());
1372            }
1373
1374            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1375            // are envelope_size bytes.
1376            let cur_offset: usize = (2 - 1) * envelope_size;
1377
1378            // Zero reserved fields.
1379            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1380
1381            // Safety:
1382            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1383            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1384            //   envelope_size bytes, there is always sufficient room.
1385            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
1386                self.subject.as_ref().map(
1387                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
1388                ),
1389                encoder,
1390                offset + cur_offset,
1391                depth,
1392            )?;
1393
1394            _prev_end_offset = cur_offset + envelope_size;
1395            if 3 > max_ordinal {
1396                return Ok(());
1397            }
1398
1399            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1400            // are envelope_size bytes.
1401            let cur_offset: usize = (3 - 1) * envelope_size;
1402
1403            // Zero reserved fields.
1404            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1405
1406            // Safety:
1407            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1408            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1409            //   envelope_size bytes, there is always sufficient room.
1410            fidl::encoding::encode_in_envelope_optional::<i64, D>(
1411                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
1412                encoder,
1413                offset + cur_offset,
1414                depth,
1415            )?;
1416
1417            _prev_end_offset = cur_offset + envelope_size;
1418            if 4 > max_ordinal {
1419                return Ok(());
1420            }
1421
1422            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1423            // are envelope_size bytes.
1424            let cur_offset: usize = (4 - 1) * envelope_size;
1425
1426            // Zero reserved fields.
1427            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1428
1429            // Safety:
1430            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1431            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1432            //   envelope_size bytes, there is always sufficient room.
1433            fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1434                self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1435                encoder,
1436                offset + cur_offset,
1437                depth,
1438            )?;
1439
1440            _prev_end_offset = cur_offset + envelope_size;
1441            if 5 > max_ordinal {
1442                return Ok(());
1443            }
1444
1445            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1446            // are envelope_size bytes.
1447            let cur_offset: usize = (5 - 1) * envelope_size;
1448
1449            // Zero reserved fields.
1450            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1451
1452            // Safety:
1453            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1454            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1455            //   envelope_size bytes, there is always sufficient room.
1456            fidl::encoding::encode_in_envelope_optional::<Audience, D>(
1457                self.recipient.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
1458                encoder,
1459                offset + cur_offset,
1460                depth,
1461            )?;
1462
1463            _prev_end_offset = cur_offset + envelope_size;
1464            if 6 > max_ordinal {
1465                return Ok(());
1466            }
1467
1468            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1469            // are envelope_size bytes.
1470            let cur_offset: usize = (6 - 1) * envelope_size;
1471
1472            // Zero reserved fields.
1473            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1474
1475            // Safety:
1476            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1477            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1478            //   envelope_size bytes, there is always sufficient room.
1479            fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
1480                self.type_.as_ref().map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
1481                encoder,
1482                offset + cur_offset,
1483                depth,
1484            )?;
1485
1486            _prev_end_offset = cur_offset + envelope_size;
1487            if 7 > max_ordinal {
1488                return Ok(());
1489            }
1490
1491            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1492            // are envelope_size bytes.
1493            let cur_offset: usize = (7 - 1) * envelope_size;
1494
1495            // Zero reserved fields.
1496            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1497
1498            // Safety:
1499            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1500            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1501            //   envelope_size bytes, there is always sufficient room.
1502            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
1503                self.content.as_ref().map(
1504                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
1505                ),
1506                encoder,
1507                offset + cur_offset,
1508                depth,
1509            )?;
1510
1511            _prev_end_offset = cur_offset + envelope_size;
1512            if 8 > max_ordinal {
1513                return Ok(());
1514            }
1515
1516            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1517            // are envelope_size bytes.
1518            let cur_offset: usize = (8 - 1) * envelope_size;
1519
1520            // Zero reserved fields.
1521            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1522
1523            // Safety:
1524            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1525            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1526            //   envelope_size bytes, there is always sufficient room.
1527            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
1528                self.folder.as_ref().map(
1529                    <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
1530                ),
1531                encoder,
1532                offset + cur_offset,
1533                depth,
1534            )?;
1535
1536            _prev_end_offset = cur_offset + envelope_size;
1537            if 9 > max_ordinal {
1538                return Ok(());
1539            }
1540
1541            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1542            // are envelope_size bytes.
1543            let cur_offset: usize = (9 - 1) * envelope_size;
1544
1545            // Zero reserved fields.
1546            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1547
1548            // Safety:
1549            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1550            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1551            //   envelope_size bytes, there is always sufficient room.
1552            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1553                self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1554                encoder,
1555                offset + cur_offset,
1556                depth,
1557            )?;
1558
1559            _prev_end_offset = cur_offset + envelope_size;
1560            if 10 > max_ordinal {
1561                return Ok(());
1562            }
1563
1564            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1565            // are envelope_size bytes.
1566            let cur_offset: usize = (10 - 1) * envelope_size;
1567
1568            // Zero reserved fields.
1569            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1570
1571            // Safety:
1572            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1573            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1574            //   envelope_size bytes, there is always sufficient room.
1575            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1576                self.read.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1577                encoder,
1578                offset + cur_offset,
1579                depth,
1580            )?;
1581
1582            _prev_end_offset = cur_offset + envelope_size;
1583            if 11 > max_ordinal {
1584                return Ok(());
1585            }
1586
1587            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1588            // are envelope_size bytes.
1589            let cur_offset: usize = (11 - 1) * envelope_size;
1590
1591            // Zero reserved fields.
1592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1593
1594            // Safety:
1595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1597            //   envelope_size bytes, there is always sufficient room.
1598            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1599                self.sent.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1600                encoder,
1601                offset + cur_offset,
1602                depth,
1603            )?;
1604
1605            _prev_end_offset = cur_offset + envelope_size;
1606            if 12 > max_ordinal {
1607                return Ok(());
1608            }
1609
1610            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1611            // are envelope_size bytes.
1612            let cur_offset: usize = (12 - 1) * envelope_size;
1613
1614            // Zero reserved fields.
1615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1616
1617            // Safety:
1618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1620            //   envelope_size bytes, there is always sufficient room.
1621            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1622                self.protected.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1623                encoder,
1624                offset + cur_offset,
1625                depth,
1626            )?;
1627
1628            _prev_end_offset = cur_offset + envelope_size;
1629            if 13 > max_ordinal {
1630                return Ok(());
1631            }
1632
1633            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1634            // are envelope_size bytes.
1635            let cur_offset: usize = (13 - 1) * envelope_size;
1636
1637            // Zero reserved fields.
1638            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1639
1640            // Safety:
1641            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1642            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1643            //   envelope_size bytes, there is always sufficient room.
1644            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
1645                self.conversation_id.as_ref().map(
1646                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
1647                ),
1648                encoder,
1649                offset + cur_offset,
1650                depth,
1651            )?;
1652
1653            _prev_end_offset = cur_offset + envelope_size;
1654
1655            Ok(())
1656        }
1657    }
1658
1659    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Message {
1660        #[inline(always)]
1661        fn new_empty() -> Self {
1662            Self::default()
1663        }
1664
1665        unsafe fn decode(
1666            &mut self,
1667            decoder: &mut fidl::encoding::Decoder<'_, D>,
1668            offset: usize,
1669            mut depth: fidl::encoding::Depth,
1670        ) -> fidl::Result<()> {
1671            decoder.debug_check_bounds::<Self>(offset);
1672            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1673                None => return Err(fidl::Error::NotNullable),
1674                Some(len) => len,
1675            };
1676            // Calling decoder.out_of_line_offset(0) is not allowed.
1677            if len == 0 {
1678                return Ok(());
1679            };
1680            depth.increment()?;
1681            let envelope_size = 8;
1682            let bytes_len = len * envelope_size;
1683            let offset = decoder.out_of_line_offset(bytes_len)?;
1684            // Decode the envelope for each type.
1685            let mut _next_ordinal_to_read = 0;
1686            let mut next_offset = offset;
1687            let end_offset = offset + bytes_len;
1688            _next_ordinal_to_read += 1;
1689            if next_offset >= end_offset {
1690                return Ok(());
1691            }
1692
1693            // Decode unknown envelopes for gaps in ordinals.
1694            while _next_ordinal_to_read < 1 {
1695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1696                _next_ordinal_to_read += 1;
1697                next_offset += envelope_size;
1698            }
1699
1700            let next_out_of_line = decoder.next_out_of_line();
1701            let handles_before = decoder.remaining_handles();
1702            if let Some((inlined, num_bytes, num_handles)) =
1703                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1704            {
1705                let member_inline_size =
1706                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1707                if inlined != (member_inline_size <= 4) {
1708                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1709                }
1710                let inner_offset;
1711                let mut inner_depth = depth.clone();
1712                if inlined {
1713                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1714                    inner_offset = next_offset;
1715                } else {
1716                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1717                    inner_depth.increment()?;
1718                }
1719                let val_ref = self.handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
1720                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1721                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1722                {
1723                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1724                }
1725                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1726                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1727                }
1728            }
1729
1730            next_offset += envelope_size;
1731            _next_ordinal_to_read += 1;
1732            if next_offset >= end_offset {
1733                return Ok(());
1734            }
1735
1736            // Decode unknown envelopes for gaps in ordinals.
1737            while _next_ordinal_to_read < 2 {
1738                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1739                _next_ordinal_to_read += 1;
1740                next_offset += envelope_size;
1741            }
1742
1743            let next_out_of_line = decoder.next_out_of_line();
1744            let handles_before = decoder.remaining_handles();
1745            if let Some((inlined, num_bytes, num_handles)) =
1746                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1747            {
1748                let member_inline_size =
1749                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
1750                        decoder.context,
1751                    );
1752                if inlined != (member_inline_size <= 4) {
1753                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1754                }
1755                let inner_offset;
1756                let mut inner_depth = depth.clone();
1757                if inlined {
1758                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1759                    inner_offset = next_offset;
1760                } else {
1761                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1762                    inner_depth.increment()?;
1763                }
1764                let val_ref = self
1765                    .subject
1766                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
1767                fidl::decode!(
1768                    fidl::encoding::BoundedString<256>,
1769                    D,
1770                    val_ref,
1771                    decoder,
1772                    inner_offset,
1773                    inner_depth
1774                )?;
1775                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1776                {
1777                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1778                }
1779                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1780                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1781                }
1782            }
1783
1784            next_offset += envelope_size;
1785            _next_ordinal_to_read += 1;
1786            if next_offset >= end_offset {
1787                return Ok(());
1788            }
1789
1790            // Decode unknown envelopes for gaps in ordinals.
1791            while _next_ordinal_to_read < 3 {
1792                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1793                _next_ordinal_to_read += 1;
1794                next_offset += envelope_size;
1795            }
1796
1797            let next_out_of_line = decoder.next_out_of_line();
1798            let handles_before = decoder.remaining_handles();
1799            if let Some((inlined, num_bytes, num_handles)) =
1800                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1801            {
1802                let member_inline_size =
1803                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1804                if inlined != (member_inline_size <= 4) {
1805                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1806                }
1807                let inner_offset;
1808                let mut inner_depth = depth.clone();
1809                if inlined {
1810                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1811                    inner_offset = next_offset;
1812                } else {
1813                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1814                    inner_depth.increment()?;
1815                }
1816                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
1817                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
1818                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1819                {
1820                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1821                }
1822                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1823                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1824                }
1825            }
1826
1827            next_offset += envelope_size;
1828            _next_ordinal_to_read += 1;
1829            if next_offset >= end_offset {
1830                return Ok(());
1831            }
1832
1833            // Decode unknown envelopes for gaps in ordinals.
1834            while _next_ordinal_to_read < 4 {
1835                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1836                _next_ordinal_to_read += 1;
1837                next_offset += envelope_size;
1838            }
1839
1840            let next_out_of_line = decoder.next_out_of_line();
1841            let handles_before = decoder.remaining_handles();
1842            if let Some((inlined, num_bytes, num_handles)) =
1843                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1844            {
1845                let member_inline_size =
1846                    <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1847                if inlined != (member_inline_size <= 4) {
1848                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1849                }
1850                let inner_offset;
1851                let mut inner_depth = depth.clone();
1852                if inlined {
1853                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1854                    inner_offset = next_offset;
1855                } else {
1856                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1857                    inner_depth.increment()?;
1858                }
1859                let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1860                fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1861                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1862                {
1863                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1864                }
1865                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1866                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1867                }
1868            }
1869
1870            next_offset += envelope_size;
1871            _next_ordinal_to_read += 1;
1872            if next_offset >= end_offset {
1873                return Ok(());
1874            }
1875
1876            // Decode unknown envelopes for gaps in ordinals.
1877            while _next_ordinal_to_read < 5 {
1878                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1879                _next_ordinal_to_read += 1;
1880                next_offset += envelope_size;
1881            }
1882
1883            let next_out_of_line = decoder.next_out_of_line();
1884            let handles_before = decoder.remaining_handles();
1885            if let Some((inlined, num_bytes, num_handles)) =
1886                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1887            {
1888                let member_inline_size =
1889                    <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1890                if inlined != (member_inline_size <= 4) {
1891                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1892                }
1893                let inner_offset;
1894                let mut inner_depth = depth.clone();
1895                if inlined {
1896                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1897                    inner_offset = next_offset;
1898                } else {
1899                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1900                    inner_depth.increment()?;
1901                }
1902                let val_ref = self.recipient.get_or_insert_with(|| fidl::new_empty!(Audience, D));
1903                fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
1904                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1905                {
1906                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1907                }
1908                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1909                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1910                }
1911            }
1912
1913            next_offset += envelope_size;
1914            _next_ordinal_to_read += 1;
1915            if next_offset >= end_offset {
1916                return Ok(());
1917            }
1918
1919            // Decode unknown envelopes for gaps in ordinals.
1920            while _next_ordinal_to_read < 6 {
1921                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1922                _next_ordinal_to_read += 1;
1923                next_offset += envelope_size;
1924            }
1925
1926            let next_out_of_line = decoder.next_out_of_line();
1927            let handles_before = decoder.remaining_handles();
1928            if let Some((inlined, num_bytes, num_handles)) =
1929                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1930            {
1931                let member_inline_size =
1932                    <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1933                if inlined != (member_inline_size <= 4) {
1934                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1935                }
1936                let inner_offset;
1937                let mut inner_depth = depth.clone();
1938                if inlined {
1939                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1940                    inner_offset = next_offset;
1941                } else {
1942                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1943                    inner_depth.increment()?;
1944                }
1945                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
1946                fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
1947                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1948                {
1949                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1950                }
1951                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1952                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1953                }
1954            }
1955
1956            next_offset += envelope_size;
1957            _next_ordinal_to_read += 1;
1958            if next_offset >= end_offset {
1959                return Ok(());
1960            }
1961
1962            // Decode unknown envelopes for gaps in ordinals.
1963            while _next_ordinal_to_read < 7 {
1964                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1965                _next_ordinal_to_read += 1;
1966                next_offset += envelope_size;
1967            }
1968
1969            let next_out_of_line = decoder.next_out_of_line();
1970            let handles_before = decoder.remaining_handles();
1971            if let Some((inlined, num_bytes, num_handles)) =
1972                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1973            {
1974                let member_inline_size =
1975                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
1976                        decoder.context,
1977                    );
1978                if inlined != (member_inline_size <= 4) {
1979                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1980                }
1981                let inner_offset;
1982                let mut inner_depth = depth.clone();
1983                if inlined {
1984                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1985                    inner_offset = next_offset;
1986                } else {
1987                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1988                    inner_depth.increment()?;
1989                }
1990                let val_ref = self
1991                    .content
1992                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
1993                fidl::decode!(
1994                    fidl::encoding::UnboundedString,
1995                    D,
1996                    val_ref,
1997                    decoder,
1998                    inner_offset,
1999                    inner_depth
2000                )?;
2001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2002                {
2003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2004                }
2005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2007                }
2008            }
2009
2010            next_offset += envelope_size;
2011            _next_ordinal_to_read += 1;
2012            if next_offset >= end_offset {
2013                return Ok(());
2014            }
2015
2016            // Decode unknown envelopes for gaps in ordinals.
2017            while _next_ordinal_to_read < 8 {
2018                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2019                _next_ordinal_to_read += 1;
2020                next_offset += envelope_size;
2021            }
2022
2023            let next_out_of_line = decoder.next_out_of_line();
2024            let handles_before = decoder.remaining_handles();
2025            if let Some((inlined, num_bytes, num_handles)) =
2026                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2027            {
2028                let member_inline_size =
2029                    <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2030                        decoder.context,
2031                    );
2032                if inlined != (member_inline_size <= 4) {
2033                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2034                }
2035                let inner_offset;
2036                let mut inner_depth = depth.clone();
2037                if inlined {
2038                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2039                    inner_offset = next_offset;
2040                } else {
2041                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2042                    inner_depth.increment()?;
2043                }
2044                let val_ref = self
2045                    .folder
2046                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2047                fidl::decode!(
2048                    fidl::encoding::BoundedString<512>,
2049                    D,
2050                    val_ref,
2051                    decoder,
2052                    inner_offset,
2053                    inner_depth
2054                )?;
2055                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2056                {
2057                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2058                }
2059                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2060                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2061                }
2062            }
2063
2064            next_offset += envelope_size;
2065            _next_ordinal_to_read += 1;
2066            if next_offset >= end_offset {
2067                return Ok(());
2068            }
2069
2070            // Decode unknown envelopes for gaps in ordinals.
2071            while _next_ordinal_to_read < 9 {
2072                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2073                _next_ordinal_to_read += 1;
2074                next_offset += envelope_size;
2075            }
2076
2077            let next_out_of_line = decoder.next_out_of_line();
2078            let handles_before = decoder.remaining_handles();
2079            if let Some((inlined, num_bytes, num_handles)) =
2080                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2081            {
2082                let member_inline_size =
2083                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2084                if inlined != (member_inline_size <= 4) {
2085                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2086                }
2087                let inner_offset;
2088                let mut inner_depth = depth.clone();
2089                if inlined {
2090                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2091                    inner_offset = next_offset;
2092                } else {
2093                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2094                    inner_depth.increment()?;
2095                }
2096                let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
2097                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2098                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2099                {
2100                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2101                }
2102                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2103                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2104                }
2105            }
2106
2107            next_offset += envelope_size;
2108            _next_ordinal_to_read += 1;
2109            if next_offset >= end_offset {
2110                return Ok(());
2111            }
2112
2113            // Decode unknown envelopes for gaps in ordinals.
2114            while _next_ordinal_to_read < 10 {
2115                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2116                _next_ordinal_to_read += 1;
2117                next_offset += envelope_size;
2118            }
2119
2120            let next_out_of_line = decoder.next_out_of_line();
2121            let handles_before = decoder.remaining_handles();
2122            if let Some((inlined, num_bytes, num_handles)) =
2123                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2124            {
2125                let member_inline_size =
2126                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2127                if inlined != (member_inline_size <= 4) {
2128                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2129                }
2130                let inner_offset;
2131                let mut inner_depth = depth.clone();
2132                if inlined {
2133                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2134                    inner_offset = next_offset;
2135                } else {
2136                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2137                    inner_depth.increment()?;
2138                }
2139                let val_ref = self.read.get_or_insert_with(|| fidl::new_empty!(bool, D));
2140                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2141                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2142                {
2143                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2144                }
2145                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2146                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2147                }
2148            }
2149
2150            next_offset += envelope_size;
2151            _next_ordinal_to_read += 1;
2152            if next_offset >= end_offset {
2153                return Ok(());
2154            }
2155
2156            // Decode unknown envelopes for gaps in ordinals.
2157            while _next_ordinal_to_read < 11 {
2158                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2159                _next_ordinal_to_read += 1;
2160                next_offset += envelope_size;
2161            }
2162
2163            let next_out_of_line = decoder.next_out_of_line();
2164            let handles_before = decoder.remaining_handles();
2165            if let Some((inlined, num_bytes, num_handles)) =
2166                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2167            {
2168                let member_inline_size =
2169                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2170                if inlined != (member_inline_size <= 4) {
2171                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2172                }
2173                let inner_offset;
2174                let mut inner_depth = depth.clone();
2175                if inlined {
2176                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2177                    inner_offset = next_offset;
2178                } else {
2179                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2180                    inner_depth.increment()?;
2181                }
2182                let val_ref = self.sent.get_or_insert_with(|| fidl::new_empty!(bool, D));
2183                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2184                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2185                {
2186                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2187                }
2188                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2189                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2190                }
2191            }
2192
2193            next_offset += envelope_size;
2194            _next_ordinal_to_read += 1;
2195            if next_offset >= end_offset {
2196                return Ok(());
2197            }
2198
2199            // Decode unknown envelopes for gaps in ordinals.
2200            while _next_ordinal_to_read < 12 {
2201                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2202                _next_ordinal_to_read += 1;
2203                next_offset += envelope_size;
2204            }
2205
2206            let next_out_of_line = decoder.next_out_of_line();
2207            let handles_before = decoder.remaining_handles();
2208            if let Some((inlined, num_bytes, num_handles)) =
2209                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2210            {
2211                let member_inline_size =
2212                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2213                if inlined != (member_inline_size <= 4) {
2214                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2215                }
2216                let inner_offset;
2217                let mut inner_depth = depth.clone();
2218                if inlined {
2219                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2220                    inner_offset = next_offset;
2221                } else {
2222                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2223                    inner_depth.increment()?;
2224                }
2225                let val_ref = self.protected.get_or_insert_with(|| fidl::new_empty!(bool, D));
2226                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2228                {
2229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2230                }
2231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2233                }
2234            }
2235
2236            next_offset += envelope_size;
2237            _next_ordinal_to_read += 1;
2238            if next_offset >= end_offset {
2239                return Ok(());
2240            }
2241
2242            // Decode unknown envelopes for gaps in ordinals.
2243            while _next_ordinal_to_read < 13 {
2244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2245                _next_ordinal_to_read += 1;
2246                next_offset += envelope_size;
2247            }
2248
2249            let next_out_of_line = decoder.next_out_of_line();
2250            let handles_before = decoder.remaining_handles();
2251            if let Some((inlined, num_bytes, num_handles)) =
2252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2253            {
2254                let member_inline_size =
2255                    <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
2256                        decoder.context,
2257                    );
2258                if inlined != (member_inline_size <= 4) {
2259                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2260                }
2261                let inner_offset;
2262                let mut inner_depth = depth.clone();
2263                if inlined {
2264                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2265                    inner_offset = next_offset;
2266                } else {
2267                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2268                    inner_depth.increment()?;
2269                }
2270                let val_ref = self
2271                    .conversation_id
2272                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
2273                fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
2274                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2275                {
2276                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2277                }
2278                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2279                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2280                }
2281            }
2282
2283            next_offset += envelope_size;
2284
2285            // Decode the remaining unknown envelopes.
2286            while next_offset < end_offset {
2287                _next_ordinal_to_read += 1;
2288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2289                next_offset += envelope_size;
2290            }
2291
2292            Ok(())
2293        }
2294    }
2295
2296    impl Notification {
2297        #[inline(always)]
2298        fn max_ordinal_present(&self) -> u64 {
2299            if let Some(_) = self.priority {
2300                return 9;
2301            }
2302            if let Some(_) = self.sender {
2303                return 8;
2304            }
2305            if let Some(_) = self.subject {
2306                return 7;
2307            }
2308            if let Some(_) = self.timestamp {
2309                return 6;
2310            }
2311            if let Some(_) = self.message_type {
2312                return 5;
2313            }
2314            if let Some(_) = self.folder {
2315                return 4;
2316            }
2317            if let Some(_) = self.message_handle {
2318                return 3;
2319            }
2320            if let Some(_) = self.mas_instance_id {
2321                return 2;
2322            }
2323            if let Some(_) = self.type_ {
2324                return 1;
2325            }
2326            0
2327        }
2328    }
2329
2330    impl fidl::encoding::ValueTypeMarker for Notification {
2331        type Borrowed<'a> = &'a Self;
2332        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2333            value
2334        }
2335    }
2336
2337    unsafe impl fidl::encoding::TypeMarker for Notification {
2338        type Owned = Self;
2339
2340        #[inline(always)]
2341        fn inline_align(_context: fidl::encoding::Context) -> usize {
2342            8
2343        }
2344
2345        #[inline(always)]
2346        fn inline_size(_context: fidl::encoding::Context) -> usize {
2347            16
2348        }
2349    }
2350
2351    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Notification, D>
2352        for &Notification
2353    {
2354        unsafe fn encode(
2355            self,
2356            encoder: &mut fidl::encoding::Encoder<'_, D>,
2357            offset: usize,
2358            mut depth: fidl::encoding::Depth,
2359        ) -> fidl::Result<()> {
2360            encoder.debug_check_bounds::<Notification>(offset);
2361            // Vector header
2362            let max_ordinal: u64 = self.max_ordinal_present();
2363            encoder.write_num(max_ordinal, offset);
2364            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2365            // Calling encoder.out_of_line_offset(0) is not allowed.
2366            if max_ordinal == 0 {
2367                return Ok(());
2368            }
2369            depth.increment()?;
2370            let envelope_size = 8;
2371            let bytes_len = max_ordinal as usize * envelope_size;
2372            #[allow(unused_variables)]
2373            let offset = encoder.out_of_line_offset(bytes_len);
2374            let mut _prev_end_offset: usize = 0;
2375            if 1 > max_ordinal {
2376                return Ok(());
2377            }
2378
2379            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2380            // are envelope_size bytes.
2381            let cur_offset: usize = (1 - 1) * envelope_size;
2382
2383            // Zero reserved fields.
2384            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2385
2386            // Safety:
2387            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2388            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2389            //   envelope_size bytes, there is always sufficient room.
2390            fidl::encoding::encode_in_envelope_optional::<NotificationType, D>(
2391                self.type_
2392                    .as_ref()
2393                    .map(<NotificationType as fidl::encoding::ValueTypeMarker>::borrow),
2394                encoder,
2395                offset + cur_offset,
2396                depth,
2397            )?;
2398
2399            _prev_end_offset = cur_offset + envelope_size;
2400            if 2 > max_ordinal {
2401                return Ok(());
2402            }
2403
2404            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2405            // are envelope_size bytes.
2406            let cur_offset: usize = (2 - 1) * envelope_size;
2407
2408            // Zero reserved fields.
2409            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411            // Safety:
2412            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2413            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2414            //   envelope_size bytes, there is always sufficient room.
2415            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2416                self.mas_instance_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2417                encoder,
2418                offset + cur_offset,
2419                depth,
2420            )?;
2421
2422            _prev_end_offset = cur_offset + envelope_size;
2423            if 3 > max_ordinal {
2424                return Ok(());
2425            }
2426
2427            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2428            // are envelope_size bytes.
2429            let cur_offset: usize = (3 - 1) * envelope_size;
2430
2431            // Zero reserved fields.
2432            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2433
2434            // Safety:
2435            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2436            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2437            //   envelope_size bytes, there is always sufficient room.
2438            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2439                self.message_handle.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2440                encoder,
2441                offset + cur_offset,
2442                depth,
2443            )?;
2444
2445            _prev_end_offset = cur_offset + envelope_size;
2446            if 4 > max_ordinal {
2447                return Ok(());
2448            }
2449
2450            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2451            // are envelope_size bytes.
2452            let cur_offset: usize = (4 - 1) * envelope_size;
2453
2454            // Zero reserved fields.
2455            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2456
2457            // Safety:
2458            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2459            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2460            //   envelope_size bytes, there is always sufficient room.
2461            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<512>, D>(
2462                self.folder.as_ref().map(
2463                    <fidl::encoding::BoundedString<512> as fidl::encoding::ValueTypeMarker>::borrow,
2464                ),
2465                encoder,
2466                offset + cur_offset,
2467                depth,
2468            )?;
2469
2470            _prev_end_offset = cur_offset + envelope_size;
2471            if 5 > max_ordinal {
2472                return Ok(());
2473            }
2474
2475            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2476            // are envelope_size bytes.
2477            let cur_offset: usize = (5 - 1) * envelope_size;
2478
2479            // Zero reserved fields.
2480            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2481
2482            // Safety:
2483            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2484            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2485            //   envelope_size bytes, there is always sufficient room.
2486            fidl::encoding::encode_in_envelope_optional::<MessageType, D>(
2487                self.message_type
2488                    .as_ref()
2489                    .map(<MessageType as fidl::encoding::ValueTypeMarker>::borrow),
2490                encoder,
2491                offset + cur_offset,
2492                depth,
2493            )?;
2494
2495            _prev_end_offset = cur_offset + envelope_size;
2496            if 6 > max_ordinal {
2497                return Ok(());
2498            }
2499
2500            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2501            // are envelope_size bytes.
2502            let cur_offset: usize = (6 - 1) * envelope_size;
2503
2504            // Zero reserved fields.
2505            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2506
2507            // Safety:
2508            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2509            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2510            //   envelope_size bytes, there is always sufficient room.
2511            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2512                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2513                encoder,
2514                offset + cur_offset,
2515                depth,
2516            )?;
2517
2518            _prev_end_offset = cur_offset + envelope_size;
2519            if 7 > max_ordinal {
2520                return Ok(());
2521            }
2522
2523            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2524            // are envelope_size bytes.
2525            let cur_offset: usize = (7 - 1) * envelope_size;
2526
2527            // Zero reserved fields.
2528            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2529
2530            // Safety:
2531            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2532            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2533            //   envelope_size bytes, there is always sufficient room.
2534            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
2535                self.subject.as_ref().map(
2536                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
2537                ),
2538                encoder,
2539                offset + cur_offset,
2540                depth,
2541            )?;
2542
2543            _prev_end_offset = cur_offset + envelope_size;
2544            if 8 > max_ordinal {
2545                return Ok(());
2546            }
2547
2548            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2549            // are envelope_size bytes.
2550            let cur_offset: usize = (8 - 1) * envelope_size;
2551
2552            // Zero reserved fields.
2553            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2554
2555            // Safety:
2556            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2557            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2558            //   envelope_size bytes, there is always sufficient room.
2559            fidl::encoding::encode_in_envelope_optional::<Audience, D>(
2560                self.sender.as_ref().map(<Audience as fidl::encoding::ValueTypeMarker>::borrow),
2561                encoder,
2562                offset + cur_offset,
2563                depth,
2564            )?;
2565
2566            _prev_end_offset = cur_offset + envelope_size;
2567            if 9 > max_ordinal {
2568                return Ok(());
2569            }
2570
2571            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2572            // are envelope_size bytes.
2573            let cur_offset: usize = (9 - 1) * envelope_size;
2574
2575            // Zero reserved fields.
2576            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2577
2578            // Safety:
2579            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2580            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2581            //   envelope_size bytes, there is always sufficient room.
2582            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2583                self.priority.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2584                encoder,
2585                offset + cur_offset,
2586                depth,
2587            )?;
2588
2589            _prev_end_offset = cur_offset + envelope_size;
2590
2591            Ok(())
2592        }
2593    }
2594
2595    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notification {
2596        #[inline(always)]
2597        fn new_empty() -> Self {
2598            Self::default()
2599        }
2600
2601        unsafe fn decode(
2602            &mut self,
2603            decoder: &mut fidl::encoding::Decoder<'_, D>,
2604            offset: usize,
2605            mut depth: fidl::encoding::Depth,
2606        ) -> fidl::Result<()> {
2607            decoder.debug_check_bounds::<Self>(offset);
2608            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2609                None => return Err(fidl::Error::NotNullable),
2610                Some(len) => len,
2611            };
2612            // Calling decoder.out_of_line_offset(0) is not allowed.
2613            if len == 0 {
2614                return Ok(());
2615            };
2616            depth.increment()?;
2617            let envelope_size = 8;
2618            let bytes_len = len * envelope_size;
2619            let offset = decoder.out_of_line_offset(bytes_len)?;
2620            // Decode the envelope for each type.
2621            let mut _next_ordinal_to_read = 0;
2622            let mut next_offset = offset;
2623            let end_offset = offset + bytes_len;
2624            _next_ordinal_to_read += 1;
2625            if next_offset >= end_offset {
2626                return Ok(());
2627            }
2628
2629            // Decode unknown envelopes for gaps in ordinals.
2630            while _next_ordinal_to_read < 1 {
2631                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2632                _next_ordinal_to_read += 1;
2633                next_offset += envelope_size;
2634            }
2635
2636            let next_out_of_line = decoder.next_out_of_line();
2637            let handles_before = decoder.remaining_handles();
2638            if let Some((inlined, num_bytes, num_handles)) =
2639                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2640            {
2641                let member_inline_size =
2642                    <NotificationType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2643                if inlined != (member_inline_size <= 4) {
2644                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2645                }
2646                let inner_offset;
2647                let mut inner_depth = depth.clone();
2648                if inlined {
2649                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2650                    inner_offset = next_offset;
2651                } else {
2652                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2653                    inner_depth.increment()?;
2654                }
2655                let val_ref =
2656                    self.type_.get_or_insert_with(|| fidl::new_empty!(NotificationType, D));
2657                fidl::decode!(NotificationType, D, val_ref, decoder, inner_offset, inner_depth)?;
2658                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2659                {
2660                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2661                }
2662                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2663                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2664                }
2665            }
2666
2667            next_offset += envelope_size;
2668            _next_ordinal_to_read += 1;
2669            if next_offset >= end_offset {
2670                return Ok(());
2671            }
2672
2673            // Decode unknown envelopes for gaps in ordinals.
2674            while _next_ordinal_to_read < 2 {
2675                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2676                _next_ordinal_to_read += 1;
2677                next_offset += envelope_size;
2678            }
2679
2680            let next_out_of_line = decoder.next_out_of_line();
2681            let handles_before = decoder.remaining_handles();
2682            if let Some((inlined, num_bytes, num_handles)) =
2683                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2684            {
2685                let member_inline_size =
2686                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2687                if inlined != (member_inline_size <= 4) {
2688                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2689                }
2690                let inner_offset;
2691                let mut inner_depth = depth.clone();
2692                if inlined {
2693                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2694                    inner_offset = next_offset;
2695                } else {
2696                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2697                    inner_depth.increment()?;
2698                }
2699                let val_ref = self.mas_instance_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
2700                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2701                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2702                {
2703                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2704                }
2705                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2706                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2707                }
2708            }
2709
2710            next_offset += envelope_size;
2711            _next_ordinal_to_read += 1;
2712            if next_offset >= end_offset {
2713                return Ok(());
2714            }
2715
2716            // Decode unknown envelopes for gaps in ordinals.
2717            while _next_ordinal_to_read < 3 {
2718                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2719                _next_ordinal_to_read += 1;
2720                next_offset += envelope_size;
2721            }
2722
2723            let next_out_of_line = decoder.next_out_of_line();
2724            let handles_before = decoder.remaining_handles();
2725            if let Some((inlined, num_bytes, num_handles)) =
2726                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2727            {
2728                let member_inline_size =
2729                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2730                if inlined != (member_inline_size <= 4) {
2731                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2732                }
2733                let inner_offset;
2734                let mut inner_depth = depth.clone();
2735                if inlined {
2736                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2737                    inner_offset = next_offset;
2738                } else {
2739                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2740                    inner_depth.increment()?;
2741                }
2742                let val_ref = self.message_handle.get_or_insert_with(|| fidl::new_empty!(u64, D));
2743                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2744                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2745                {
2746                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2747                }
2748                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2749                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2750                }
2751            }
2752
2753            next_offset += envelope_size;
2754            _next_ordinal_to_read += 1;
2755            if next_offset >= end_offset {
2756                return Ok(());
2757            }
2758
2759            // Decode unknown envelopes for gaps in ordinals.
2760            while _next_ordinal_to_read < 4 {
2761                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2762                _next_ordinal_to_read += 1;
2763                next_offset += envelope_size;
2764            }
2765
2766            let next_out_of_line = decoder.next_out_of_line();
2767            let handles_before = decoder.remaining_handles();
2768            if let Some((inlined, num_bytes, num_handles)) =
2769                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2770            {
2771                let member_inline_size =
2772                    <fidl::encoding::BoundedString<512> as fidl::encoding::TypeMarker>::inline_size(
2773                        decoder.context,
2774                    );
2775                if inlined != (member_inline_size <= 4) {
2776                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2777                }
2778                let inner_offset;
2779                let mut inner_depth = depth.clone();
2780                if inlined {
2781                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2782                    inner_offset = next_offset;
2783                } else {
2784                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2785                    inner_depth.increment()?;
2786                }
2787                let val_ref = self
2788                    .folder
2789                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<512>, D));
2790                fidl::decode!(
2791                    fidl::encoding::BoundedString<512>,
2792                    D,
2793                    val_ref,
2794                    decoder,
2795                    inner_offset,
2796                    inner_depth
2797                )?;
2798                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2799                {
2800                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2801                }
2802                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2803                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2804                }
2805            }
2806
2807            next_offset += envelope_size;
2808            _next_ordinal_to_read += 1;
2809            if next_offset >= end_offset {
2810                return Ok(());
2811            }
2812
2813            // Decode unknown envelopes for gaps in ordinals.
2814            while _next_ordinal_to_read < 5 {
2815                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816                _next_ordinal_to_read += 1;
2817                next_offset += envelope_size;
2818            }
2819
2820            let next_out_of_line = decoder.next_out_of_line();
2821            let handles_before = decoder.remaining_handles();
2822            if let Some((inlined, num_bytes, num_handles)) =
2823                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2824            {
2825                let member_inline_size =
2826                    <MessageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2827                if inlined != (member_inline_size <= 4) {
2828                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2829                }
2830                let inner_offset;
2831                let mut inner_depth = depth.clone();
2832                if inlined {
2833                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2834                    inner_offset = next_offset;
2835                } else {
2836                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2837                    inner_depth.increment()?;
2838                }
2839                let val_ref =
2840                    self.message_type.get_or_insert_with(|| fidl::new_empty!(MessageType, D));
2841                fidl::decode!(MessageType, D, val_ref, decoder, inner_offset, inner_depth)?;
2842                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2843                {
2844                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2845                }
2846                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2847                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2848                }
2849            }
2850
2851            next_offset += envelope_size;
2852            _next_ordinal_to_read += 1;
2853            if next_offset >= end_offset {
2854                return Ok(());
2855            }
2856
2857            // Decode unknown envelopes for gaps in ordinals.
2858            while _next_ordinal_to_read < 6 {
2859                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2860                _next_ordinal_to_read += 1;
2861                next_offset += envelope_size;
2862            }
2863
2864            let next_out_of_line = decoder.next_out_of_line();
2865            let handles_before = decoder.remaining_handles();
2866            if let Some((inlined, num_bytes, num_handles)) =
2867                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2868            {
2869                let member_inline_size =
2870                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2871                if inlined != (member_inline_size <= 4) {
2872                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2873                }
2874                let inner_offset;
2875                let mut inner_depth = depth.clone();
2876                if inlined {
2877                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2878                    inner_offset = next_offset;
2879                } else {
2880                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2881                    inner_depth.increment()?;
2882                }
2883                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
2884                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2885                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2886                {
2887                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2888                }
2889                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2890                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2891                }
2892            }
2893
2894            next_offset += envelope_size;
2895            _next_ordinal_to_read += 1;
2896            if next_offset >= end_offset {
2897                return Ok(());
2898            }
2899
2900            // Decode unknown envelopes for gaps in ordinals.
2901            while _next_ordinal_to_read < 7 {
2902                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2903                _next_ordinal_to_read += 1;
2904                next_offset += envelope_size;
2905            }
2906
2907            let next_out_of_line = decoder.next_out_of_line();
2908            let handles_before = decoder.remaining_handles();
2909            if let Some((inlined, num_bytes, num_handles)) =
2910                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2911            {
2912                let member_inline_size =
2913                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
2914                        decoder.context,
2915                    );
2916                if inlined != (member_inline_size <= 4) {
2917                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2918                }
2919                let inner_offset;
2920                let mut inner_depth = depth.clone();
2921                if inlined {
2922                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2923                    inner_offset = next_offset;
2924                } else {
2925                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2926                    inner_depth.increment()?;
2927                }
2928                let val_ref = self
2929                    .subject
2930                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
2931                fidl::decode!(
2932                    fidl::encoding::BoundedString<256>,
2933                    D,
2934                    val_ref,
2935                    decoder,
2936                    inner_offset,
2937                    inner_depth
2938                )?;
2939                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2940                {
2941                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2942                }
2943                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2944                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2945                }
2946            }
2947
2948            next_offset += envelope_size;
2949            _next_ordinal_to_read += 1;
2950            if next_offset >= end_offset {
2951                return Ok(());
2952            }
2953
2954            // Decode unknown envelopes for gaps in ordinals.
2955            while _next_ordinal_to_read < 8 {
2956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2957                _next_ordinal_to_read += 1;
2958                next_offset += envelope_size;
2959            }
2960
2961            let next_out_of_line = decoder.next_out_of_line();
2962            let handles_before = decoder.remaining_handles();
2963            if let Some((inlined, num_bytes, num_handles)) =
2964                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2965            {
2966                let member_inline_size =
2967                    <Audience as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2968                if inlined != (member_inline_size <= 4) {
2969                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2970                }
2971                let inner_offset;
2972                let mut inner_depth = depth.clone();
2973                if inlined {
2974                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2975                    inner_offset = next_offset;
2976                } else {
2977                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2978                    inner_depth.increment()?;
2979                }
2980                let val_ref = self.sender.get_or_insert_with(|| fidl::new_empty!(Audience, D));
2981                fidl::decode!(Audience, D, val_ref, decoder, inner_offset, inner_depth)?;
2982                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2983                {
2984                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2985                }
2986                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2987                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2988                }
2989            }
2990
2991            next_offset += envelope_size;
2992            _next_ordinal_to_read += 1;
2993            if next_offset >= end_offset {
2994                return Ok(());
2995            }
2996
2997            // Decode unknown envelopes for gaps in ordinals.
2998            while _next_ordinal_to_read < 9 {
2999                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3000                _next_ordinal_to_read += 1;
3001                next_offset += envelope_size;
3002            }
3003
3004            let next_out_of_line = decoder.next_out_of_line();
3005            let handles_before = decoder.remaining_handles();
3006            if let Some((inlined, num_bytes, num_handles)) =
3007                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3008            {
3009                let member_inline_size =
3010                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3011                if inlined != (member_inline_size <= 4) {
3012                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3013                }
3014                let inner_offset;
3015                let mut inner_depth = depth.clone();
3016                if inlined {
3017                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3018                    inner_offset = next_offset;
3019                } else {
3020                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3021                    inner_depth.increment()?;
3022                }
3023                let val_ref = self.priority.get_or_insert_with(|| fidl::new_empty!(bool, D));
3024                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3025                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3026                {
3027                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3028                }
3029                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3030                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3031                }
3032            }
3033
3034            next_offset += envelope_size;
3035
3036            // Decode the remaining unknown envelopes.
3037            while next_offset < end_offset {
3038                _next_ordinal_to_read += 1;
3039                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3040                next_offset += envelope_size;
3041            }
3042
3043            Ok(())
3044        }
3045    }
3046
3047    impl NotificationRegistrationNewEventReportRequest {
3048        #[inline(always)]
3049        fn max_ordinal_present(&self) -> u64 {
3050            if let Some(_) = self.received {
3051                return 2;
3052            }
3053            if let Some(_) = self.notification {
3054                return 1;
3055            }
3056            0
3057        }
3058    }
3059
3060    impl fidl::encoding::ValueTypeMarker for NotificationRegistrationNewEventReportRequest {
3061        type Borrowed<'a> = &'a Self;
3062        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3063            value
3064        }
3065    }
3066
3067    unsafe impl fidl::encoding::TypeMarker for NotificationRegistrationNewEventReportRequest {
3068        type Owned = Self;
3069
3070        #[inline(always)]
3071        fn inline_align(_context: fidl::encoding::Context) -> usize {
3072            8
3073        }
3074
3075        #[inline(always)]
3076        fn inline_size(_context: fidl::encoding::Context) -> usize {
3077            16
3078        }
3079    }
3080
3081    unsafe impl<D: fidl::encoding::ResourceDialect>
3082        fidl::encoding::Encode<NotificationRegistrationNewEventReportRequest, D>
3083        for &NotificationRegistrationNewEventReportRequest
3084    {
3085        unsafe fn encode(
3086            self,
3087            encoder: &mut fidl::encoding::Encoder<'_, D>,
3088            offset: usize,
3089            mut depth: fidl::encoding::Depth,
3090        ) -> fidl::Result<()> {
3091            encoder.debug_check_bounds::<NotificationRegistrationNewEventReportRequest>(offset);
3092            // Vector header
3093            let max_ordinal: u64 = self.max_ordinal_present();
3094            encoder.write_num(max_ordinal, offset);
3095            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3096            // Calling encoder.out_of_line_offset(0) is not allowed.
3097            if max_ordinal == 0 {
3098                return Ok(());
3099            }
3100            depth.increment()?;
3101            let envelope_size = 8;
3102            let bytes_len = max_ordinal as usize * envelope_size;
3103            #[allow(unused_variables)]
3104            let offset = encoder.out_of_line_offset(bytes_len);
3105            let mut _prev_end_offset: usize = 0;
3106            if 1 > max_ordinal {
3107                return Ok(());
3108            }
3109
3110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3111            // are envelope_size bytes.
3112            let cur_offset: usize = (1 - 1) * envelope_size;
3113
3114            // Zero reserved fields.
3115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3116
3117            // Safety:
3118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3120            //   envelope_size bytes, there is always sufficient room.
3121            fidl::encoding::encode_in_envelope_optional::<Notification, D>(
3122                self.notification
3123                    .as_ref()
3124                    .map(<Notification as fidl::encoding::ValueTypeMarker>::borrow),
3125                encoder,
3126                offset + cur_offset,
3127                depth,
3128            )?;
3129
3130            _prev_end_offset = cur_offset + envelope_size;
3131            if 2 > max_ordinal {
3132                return Ok(());
3133            }
3134
3135            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3136            // are envelope_size bytes.
3137            let cur_offset: usize = (2 - 1) * envelope_size;
3138
3139            // Zero reserved fields.
3140            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3141
3142            // Safety:
3143            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3144            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3145            //   envelope_size bytes, there is always sufficient room.
3146            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3147                self.received.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3148                encoder,
3149                offset + cur_offset,
3150                depth,
3151            )?;
3152
3153            _prev_end_offset = cur_offset + envelope_size;
3154
3155            Ok(())
3156        }
3157    }
3158
3159    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3160        for NotificationRegistrationNewEventReportRequest
3161    {
3162        #[inline(always)]
3163        fn new_empty() -> Self {
3164            Self::default()
3165        }
3166
3167        unsafe fn decode(
3168            &mut self,
3169            decoder: &mut fidl::encoding::Decoder<'_, D>,
3170            offset: usize,
3171            mut depth: fidl::encoding::Depth,
3172        ) -> fidl::Result<()> {
3173            decoder.debug_check_bounds::<Self>(offset);
3174            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3175                None => return Err(fidl::Error::NotNullable),
3176                Some(len) => len,
3177            };
3178            // Calling decoder.out_of_line_offset(0) is not allowed.
3179            if len == 0 {
3180                return Ok(());
3181            };
3182            depth.increment()?;
3183            let envelope_size = 8;
3184            let bytes_len = len * envelope_size;
3185            let offset = decoder.out_of_line_offset(bytes_len)?;
3186            // Decode the envelope for each type.
3187            let mut _next_ordinal_to_read = 0;
3188            let mut next_offset = offset;
3189            let end_offset = offset + bytes_len;
3190            _next_ordinal_to_read += 1;
3191            if next_offset >= end_offset {
3192                return Ok(());
3193            }
3194
3195            // Decode unknown envelopes for gaps in ordinals.
3196            while _next_ordinal_to_read < 1 {
3197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3198                _next_ordinal_to_read += 1;
3199                next_offset += envelope_size;
3200            }
3201
3202            let next_out_of_line = decoder.next_out_of_line();
3203            let handles_before = decoder.remaining_handles();
3204            if let Some((inlined, num_bytes, num_handles)) =
3205                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3206            {
3207                let member_inline_size =
3208                    <Notification as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3209                if inlined != (member_inline_size <= 4) {
3210                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3211                }
3212                let inner_offset;
3213                let mut inner_depth = depth.clone();
3214                if inlined {
3215                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3216                    inner_offset = next_offset;
3217                } else {
3218                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3219                    inner_depth.increment()?;
3220                }
3221                let val_ref =
3222                    self.notification.get_or_insert_with(|| fidl::new_empty!(Notification, D));
3223                fidl::decode!(Notification, D, val_ref, decoder, inner_offset, inner_depth)?;
3224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3225                {
3226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3227                }
3228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3230                }
3231            }
3232
3233            next_offset += envelope_size;
3234            _next_ordinal_to_read += 1;
3235            if next_offset >= end_offset {
3236                return Ok(());
3237            }
3238
3239            // Decode unknown envelopes for gaps in ordinals.
3240            while _next_ordinal_to_read < 2 {
3241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3242                _next_ordinal_to_read += 1;
3243                next_offset += envelope_size;
3244            }
3245
3246            let next_out_of_line = decoder.next_out_of_line();
3247            let handles_before = decoder.remaining_handles();
3248            if let Some((inlined, num_bytes, num_handles)) =
3249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3250            {
3251                let member_inline_size =
3252                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3253                if inlined != (member_inline_size <= 4) {
3254                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3255                }
3256                let inner_offset;
3257                let mut inner_depth = depth.clone();
3258                if inlined {
3259                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3260                    inner_offset = next_offset;
3261                } else {
3262                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3263                    inner_depth.increment()?;
3264                }
3265                let val_ref = self.received.get_or_insert_with(|| fidl::new_empty!(i64, D));
3266                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3267                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3268                {
3269                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3270                }
3271                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3272                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3273                }
3274            }
3275
3276            next_offset += envelope_size;
3277
3278            // Decode the remaining unknown envelopes.
3279            while next_offset < end_offset {
3280                _next_ordinal_to_read += 1;
3281                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3282                next_offset += envelope_size;
3283            }
3284
3285            Ok(())
3286        }
3287    }
3288}