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