fidl_fuchsia_bluetooth_avrcp__common/
fidl_fuchsia_bluetooth_avrcp__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
11/// The total number of attributes that can be set. The custom attributes + the 4
12/// defined attributes, `PlayerApplicationSettingAttributeId`. 4 + 127 = 131.
13pub const MAX_ATTRIBUTES: u64 = 131;
14
15/// The maximum number of possible values an attribute can take on.
16/// Defined by AVRCP 1.6.2 Sec 6.5.2
17pub const MAX_ATTRIBUTE_VALUES: u64 = 255;
18
19/// The maximum length of an attribute value in the media attributes.
20/// Defined by AVRCP 1.6.2 Sec 6.6.1.
21pub const MAX_ATTRIBUTE_VALUE_LENGTH: u64 = 65535;
22
23/// The maximum number of custom attributes that can be used.
24/// Defined by AVRCP 1.6.2 Appendix F.
25pub const MAX_CUSTOM_ATTRIBUTES: u64 = 127;
26
27/// The maximum number of MediaPlayerItems that can be returned from a call to
28/// GetFileSystemItems.
29/// This value is arbitrary and is meant to limit the number of items that can be returned.
30/// AVRCP 1.6.2, Section 6.10.4.2.2 defines the `Number of Items` parameter as a uint16.
31pub const MAX_FILESYSTEM_ITEMS: u16 = 16;
32
33/// The maximum number of MediaPlayerItems that can be returned from a call to
34/// GetMediaPlayerItems.
35/// This value is arbitrary and is meant to limit the number of items that can be returned.
36/// AVRCP 1.6.2, Section 6.10.4.2.2 defines the `Number of Items` parameter as a uint16.
37pub const MAX_MEDIA_PLAYER_ITEMS: u16 = 16;
38
39/// The maximum number of Notification Event IDs that can be supported by the TG.
40/// 0x0E to 0xFF are reserved for future use.
41/// Defined by AVRCP 1.6.2 Appendix H.
42pub const MAX_NOTIFICATIONS: u8 = 255;
43
44/// The maximum number of MediaPlayerItems that can be returned from a call to
45/// GetFileSystemItems.
46/// This value is arbitrary and is meant to limit the number of items that can be returned.
47/// AVRCP 1.6.2, Section 6.10.4.2.2 defines the `Number of Items` parameter as a uint16.
48pub const MAX_NOW_PLAYING_ITEMS: u16 = 16;
49
50/// The maximum number of MediaAttributeId that can be returned from a call to
51/// GetFileSystemItems or GetNowPlayingItems.
52/// This value based on list of media attributes available as per
53/// AVRCP 1.6.2, 26 Appendix E: list of media attributes.
54pub const MAX_NUM_MEDIA_ATTRIBUTES: u8 = 8;
55
56bitflags! {
57    /// The Major Player Type associated with a media player.
58    /// Defined by AVRCP 1.6.2 section 6.10.2.1.
59    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
60    pub struct MajorPlayerType: u8 {
61        const AUDIO = 1;
62        const VIDEO = 2;
63        const BROADCASTING_AUDIO = 4;
64        const BROADCASTING_VIDEO = 8;
65    }
66}
67
68impl MajorPlayerType {}
69
70bitflags! {
71    /// Change notifications that a controller client can register.
72    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
73    pub struct Notifications: u32 {
74        /// AVRCP `EVENT_PLAYBACK_STATUS_CHANGED` Notification
75        const PLAYBACK_STATUS = 1;
76        /// AVRCP `EVENT_TRACK_CHANGED` Notification
77        const TRACK = 2;
78        /// AVRCP `EVENT_TRACK_POS_CHANGED` Notification
79        const TRACK_POS = 4;
80        /// AVRCP `EVENT_BATT_STATUS_CHANGED` Notification
81        const BATT_STATUS = 8;
82        /// AVRCP `EVENT_SYSTEM_STATUS_CHANGED` Notification
83        const SYSTEM_STATUS = 16;
84        /// AVRCP `EVENT_PLAYER_APPLICATION_SETTINGS_CHANGED` Notification
85        const PLAYER_APPLICATION_SETTINGS = 32;
86        /// AVRCP `EVENT_ADDRESSED_PLAYER_CHANGED` Notification
87        const ADDRESSED_PLAYER = 64;
88        /// AVRCP `EVENT_VOLUME_CHANGED` Notification
89        const VOLUME = 128;
90        /// AVRCP `EVENT_AVAILABLE_PLAYERS_CHANGED` Notification
91        const AVAILABLE_PLAYERS = 256;
92        /// Internal connection change event.
93        const CONNECTION = 65536;
94    }
95}
96
97impl Notifications {}
98
99bitflags! {
100    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
101    pub struct PlayerFeatureBits: u64 {
102        const SELECT = 72057594037927936;
103        const UP = 144115188075855872;
104        const DOWN = 288230376151711744;
105        const LEFT = 576460752303423488;
106        const RIGHT = 1152921504606846976;
107        const RIGHT_UP = 2305843009213693952;
108        const RIGHT_DOWN = 4611686018427387904;
109        const LEFT_UP = 9223372036854775808;
110        const LEFT_DOWN = 281474976710656;
111        const ROOT_MENU = 562949953421312;
112        const SETUP_MENU = 1125899906842624;
113        const CONTENTS_MENU = 2251799813685248;
114        const FAVORITE_MENU = 4503599627370496;
115        const EXIT = 9007199254740992;
116        const ZERO = 18014398509481984;
117        const ONE = 36028797018963968;
118        const TWO = 1099511627776;
119        const THREE = 2199023255552;
120        const FOUR = 4398046511104;
121        const FIVE = 8796093022208;
122        const SIX = 17592186044416;
123        const SEVEN = 35184372088832;
124        const EIGHT = 70368744177664;
125        const NINE = 140737488355328;
126        const DOT = 4294967296;
127        const ENTER = 8589934592;
128        const CLEAR = 17179869184;
129        const CHANNEL_UP = 34359738368;
130        const CHANNEL_DOWN = 68719476736;
131        const PREVIOUS_CHANNEL = 137438953472;
132        const SOUND_SELECT = 274877906944;
133        const INPUT_SELECT = 549755813888;
134        const DISPLAY_INFORMATION = 16777216;
135        const HELP = 33554432;
136        const PAGE_UP = 67108864;
137        const PAGE_DOWN = 134217728;
138        const POWER = 268435456;
139        const VOLUME_UP = 536870912;
140        const VOLUME_DOWN = 1073741824;
141        const MUTE = 2147483648;
142        const PLAY = 65536;
143        const STOP = 131072;
144        const PAUSE = 262144;
145        const RECORD = 524288;
146        const REWIND = 1048576;
147        const FAST_FORWARD = 2097152;
148        const EJECT = 4194304;
149        const FORWARD = 8388608;
150        const BACKWARD = 256;
151        const ANGLE = 512;
152        const SUBPICTURE = 1024;
153        const F1 = 2048;
154        const F2 = 4096;
155        const F3 = 8192;
156        const F4 = 16384;
157        const F5 = 32768;
158        const VENDOR_UNIQUE = 1;
159        const BASIC_GROUP_NAVIGATION = 2;
160        const ADVANCED_CONTROL_PLAYER = 4;
161        const BROWSING = 8;
162        const SEARCHING = 16;
163        const ADD_TO_NOW_PLAYING = 32;
164        const UIDS_UNIQUE_IN_PLAYER_BROWSE_TREE = 64;
165        const ONLY_BROWSABLE_WHEN_ADDRESSED = 128;
166    }
167}
168
169impl PlayerFeatureBits {}
170
171bitflags! {
172    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
173    pub struct PlayerFeatureBitsExt: u64 {
174        const ONLY_SEARCHABLE_WHEN_ADDRESSED = 72057594037927936;
175        const NOW_PLAYING = 144115188075855872;
176        const UID_PERSISTENCY = 288230376151711744;
177        const NUMBER_OF_ITEMS = 576460752303423488;
178        const COVER_ART = 1152921504606846976;
179    }
180}
181
182impl PlayerFeatureBitsExt {}
183
184bitflags! {
185    /// The Player Sub Type associated with a media player.
186    /// Defined by AVRCP 1.6.2 section 6.10.2.1.
187    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
188    pub struct PlayerSubType: u32 {
189        const AUDIO_BOOK = 1;
190        const PODCAST = 2;
191    }
192}
193
194impl PlayerSubType {}
195
196/// Defined by AV\C Panel specification.
197#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
198#[repr(u8)]
199pub enum AvcPanelCommand {
200    Select = 0,
201    Up = 1,
202    Down = 2,
203    Left = 3,
204    Right = 4,
205    RootMenu = 9,
206    ContentsMenu = 11,
207    FavoriteMenu = 12,
208    Exit = 13,
209    OnDemandMenu = 14,
210    AppsMenu = 15,
211    Key0 = 32,
212    Key1 = 33,
213    Key2 = 34,
214    Key3 = 35,
215    Key4 = 36,
216    Key5 = 37,
217    Key6 = 38,
218    Key7 = 39,
219    Key8 = 40,
220    Key9 = 41,
221    Dot = 42,
222    Enter = 43,
223    ChannelUp = 48,
224    ChannelDown = 49,
225    ChannelPrevious = 50,
226    InputSelect = 52,
227    Info = 53,
228    Help = 54,
229    PageUp = 55,
230    PageDown = 56,
231    Lock = 58,
232    Power = 64,
233    VolumeUp = 65,
234    VolumeDown = 66,
235    Mute = 67,
236    Play = 68,
237    Stop = 69,
238    Pause = 70,
239    Record = 71,
240    Rewind = 72,
241    FastForward = 73,
242    Eject = 74,
243    Forward = 75,
244    Backward = 76,
245    List = 77,
246    F1 = 113,
247    F2 = 114,
248    F3 = 115,
249    F4 = 116,
250    F5 = 117,
251    F6 = 118,
252    F7 = 119,
253    F8 = 120,
254    F9 = 121,
255    Red = 122,
256    Green = 123,
257    Blue = 124,
258    Yellow = 125,
259}
260
261impl AvcPanelCommand {
262    #[inline]
263    pub fn from_primitive(prim: u8) -> Option<Self> {
264        match prim {
265            0 => Some(Self::Select),
266            1 => Some(Self::Up),
267            2 => Some(Self::Down),
268            3 => Some(Self::Left),
269            4 => Some(Self::Right),
270            9 => Some(Self::RootMenu),
271            11 => Some(Self::ContentsMenu),
272            12 => Some(Self::FavoriteMenu),
273            13 => Some(Self::Exit),
274            14 => Some(Self::OnDemandMenu),
275            15 => Some(Self::AppsMenu),
276            32 => Some(Self::Key0),
277            33 => Some(Self::Key1),
278            34 => Some(Self::Key2),
279            35 => Some(Self::Key3),
280            36 => Some(Self::Key4),
281            37 => Some(Self::Key5),
282            38 => Some(Self::Key6),
283            39 => Some(Self::Key7),
284            40 => Some(Self::Key8),
285            41 => Some(Self::Key9),
286            42 => Some(Self::Dot),
287            43 => Some(Self::Enter),
288            48 => Some(Self::ChannelUp),
289            49 => Some(Self::ChannelDown),
290            50 => Some(Self::ChannelPrevious),
291            52 => Some(Self::InputSelect),
292            53 => Some(Self::Info),
293            54 => Some(Self::Help),
294            55 => Some(Self::PageUp),
295            56 => Some(Self::PageDown),
296            58 => Some(Self::Lock),
297            64 => Some(Self::Power),
298            65 => Some(Self::VolumeUp),
299            66 => Some(Self::VolumeDown),
300            67 => Some(Self::Mute),
301            68 => Some(Self::Play),
302            69 => Some(Self::Stop),
303            70 => Some(Self::Pause),
304            71 => Some(Self::Record),
305            72 => Some(Self::Rewind),
306            73 => Some(Self::FastForward),
307            74 => Some(Self::Eject),
308            75 => Some(Self::Forward),
309            76 => Some(Self::Backward),
310            77 => Some(Self::List),
311            113 => Some(Self::F1),
312            114 => Some(Self::F2),
313            115 => Some(Self::F3),
314            116 => Some(Self::F4),
315            117 => Some(Self::F5),
316            118 => Some(Self::F6),
317            119 => Some(Self::F7),
318            120 => Some(Self::F8),
319            121 => Some(Self::F9),
320            122 => Some(Self::Red),
321            123 => Some(Self::Green),
322            124 => Some(Self::Blue),
323            125 => Some(Self::Yellow),
324            _ => None,
325        }
326    }
327
328    #[inline]
329    pub const fn into_primitive(self) -> u8 {
330        self as u8
331    }
332}
333
334/// Defined by AVRCP 1.6.2 section 6.7.2 (RegisterNotification).
335/// Format for `EVENT_BATT_STATUS_CHANGED`.
336/// Same encoding also defined by 6.5.8 (InformBatteryStatusOfCT).
337#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
338#[repr(u8)]
339pub enum BatteryStatus {
340    Normal = 0,
341    Warning = 1,
342    Critical = 2,
343    External = 3,
344    FullCharge = 4,
345    Reserved = 5,
346}
347
348impl BatteryStatus {
349    #[inline]
350    pub fn from_primitive(prim: u8) -> Option<Self> {
351        match prim {
352            0 => Some(Self::Normal),
353            1 => Some(Self::Warning),
354            2 => Some(Self::Critical),
355            3 => Some(Self::External),
356            4 => Some(Self::FullCharge),
357            5 => Some(Self::Reserved),
358            _ => None,
359        }
360    }
361
362    #[inline]
363    pub const fn into_primitive(self) -> u8 {
364        self as u8
365    }
366}
367
368/// Errors from AVRCP 1.6.2 Section 6.15.3.
369#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
370#[repr(u32)]
371pub enum BrowseControllerError {
372    UnknownFailure = 1,
373    TimedOut = 2,
374    RemoteNotConnected = 3,
375    CommandNotImplemented = 4,
376    CommandRejected = 5,
377    CommandUnexpected = 6,
378    PacketEncoding = 7,
379    ProtocolError = 8,
380    ConnectionError = 9,
381    UidChanged = 10,
382    InvalidDirection = 11,
383    InvalidId = 12,
384    InvalidScope = 13,
385    RangeOutOfBounds = 14,
386    ItemNotPlayable = 15,
387    MediaInUse = 16,
388    PlayerNotBrowsable = 17,
389    PlayerNotAddressed = 18,
390    NoValidResults = 19,
391    NoAvailablePlayers = 20,
392}
393
394impl BrowseControllerError {
395    #[inline]
396    pub fn from_primitive(prim: u32) -> Option<Self> {
397        match prim {
398            1 => Some(Self::UnknownFailure),
399            2 => Some(Self::TimedOut),
400            3 => Some(Self::RemoteNotConnected),
401            4 => Some(Self::CommandNotImplemented),
402            5 => Some(Self::CommandRejected),
403            6 => Some(Self::CommandUnexpected),
404            7 => Some(Self::PacketEncoding),
405            8 => Some(Self::ProtocolError),
406            9 => Some(Self::ConnectionError),
407            10 => Some(Self::UidChanged),
408            11 => Some(Self::InvalidDirection),
409            12 => Some(Self::InvalidId),
410            13 => Some(Self::InvalidScope),
411            14 => Some(Self::RangeOutOfBounds),
412            15 => Some(Self::ItemNotPlayable),
413            16 => Some(Self::MediaInUse),
414            17 => Some(Self::PlayerNotBrowsable),
415            18 => Some(Self::PlayerNotAddressed),
416            19 => Some(Self::NoValidResults),
417            20 => Some(Self::NoAvailablePlayers),
418            _ => None,
419        }
420    }
421
422    #[inline]
423    pub const fn into_primitive(self) -> u32 {
424        self as u32
425    }
426}
427
428/// Status codes for commands sent as the controller.
429#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
430#[repr(u32)]
431pub enum ControllerError {
432    UnknownFailure = 1,
433    TimedOut = 2,
434    RemoteNotConnected = 3,
435    CommandNotImplemented = 4,
436    CommandRejected = 5,
437    CommandUnexpected = 6,
438    InvalidArguments = 7,
439    PacketEncoding = 8,
440    ProtocolError = 9,
441    ConnectionError = 10,
442    UnexpectedResponse = 11,
443}
444
445impl ControllerError {
446    #[inline]
447    pub fn from_primitive(prim: u32) -> Option<Self> {
448        match prim {
449            1 => Some(Self::UnknownFailure),
450            2 => Some(Self::TimedOut),
451            3 => Some(Self::RemoteNotConnected),
452            4 => Some(Self::CommandNotImplemented),
453            5 => Some(Self::CommandRejected),
454            6 => Some(Self::CommandUnexpected),
455            7 => Some(Self::InvalidArguments),
456            8 => Some(Self::PacketEncoding),
457            9 => Some(Self::ProtocolError),
458            10 => Some(Self::ConnectionError),
459            11 => Some(Self::UnexpectedResponse),
460            _ => None,
461        }
462    }
463
464    #[inline]
465    pub const fn into_primitive(self) -> u32 {
466        self as u32
467    }
468}
469
470/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
471#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
472#[repr(u8)]
473pub enum Equalizer {
474    Off = 1,
475    On = 2,
476}
477
478impl Equalizer {
479    #[inline]
480    pub fn from_primitive(prim: u8) -> Option<Self> {
481        match prim {
482            1 => Some(Self::Off),
483            2 => Some(Self::On),
484            _ => None,
485        }
486    }
487
488    #[inline]
489    pub const fn into_primitive(self) -> u8 {
490        self as u8
491    }
492}
493
494/// The folder type associated with a folder item.
495/// Defined by AVRCP 1.6.2 section 6.10.2.2.
496#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
497#[repr(u8)]
498pub enum FolderType {
499    Mixed = 0,
500    Titles = 1,
501    Albums = 2,
502    Artists = 3,
503    Genres = 4,
504    Playlists = 5,
505    Years = 6,
506}
507
508impl FolderType {
509    #[inline]
510    pub fn from_primitive(prim: u8) -> Option<Self> {
511        match prim {
512            0 => Some(Self::Mixed),
513            1 => Some(Self::Titles),
514            2 => Some(Self::Albums),
515            3 => Some(Self::Artists),
516            4 => Some(Self::Genres),
517            5 => Some(Self::Playlists),
518            6 => Some(Self::Years),
519            _ => None,
520        }
521    }
522
523    #[inline]
524    pub const fn into_primitive(self) -> u8 {
525        self as u8
526    }
527}
528
529/// Defined by AVRCP 1.6.2 Appendix E (media attributes).
530/// 0x9-0xFFFFFFFF reserved for future use.
531#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
532#[repr(u32)]
533pub enum MediaAttributeId {
534    Title = 1,
535    ArtistName = 2,
536    AlbumName = 3,
537    TrackNumber = 4,
538    TotalNumberOfTracks = 5,
539    Genre = 6,
540    PlayingTime = 7,
541    DefaultCoverArt = 8,
542}
543
544impl MediaAttributeId {
545    #[inline]
546    pub fn from_primitive(prim: u32) -> Option<Self> {
547        match prim {
548            1 => Some(Self::Title),
549            2 => Some(Self::ArtistName),
550            3 => Some(Self::AlbumName),
551            4 => Some(Self::TrackNumber),
552            5 => Some(Self::TotalNumberOfTracks),
553            6 => Some(Self::Genre),
554            7 => Some(Self::PlayingTime),
555            8 => Some(Self::DefaultCoverArt),
556            _ => None,
557        }
558    }
559
560    #[inline]
561    pub const fn into_primitive(self) -> u32 {
562        self as u32
563    }
564}
565
566/// Type of a media element item.
567/// Defined by AVRCP 1.6.2 section 6.10.2.3.
568#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
569#[repr(u8)]
570pub enum MediaType {
571    Audio = 0,
572    Video = 1,
573}
574
575impl MediaType {
576    #[inline]
577    pub fn from_primitive(prim: u8) -> Option<Self> {
578        match prim {
579            0 => Some(Self::Audio),
580            1 => Some(Self::Video),
581            _ => None,
582        }
583    }
584
585    #[inline]
586    pub const fn into_primitive(self) -> u8 {
587        self as u8
588    }
589}
590
591/// Defined by AVRCP 1.6.2 section 6.7.2 (RegisterNotification) and Appendix H.
592/// Style note: named exactly as they are in the specification with the "EVENT_" prefix.
593#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
594#[repr(u8)]
595pub enum NotificationEvent {
596    PlaybackStatusChanged = 1,
597    TrackChanged = 2,
598    TrackReachedEnd = 3,
599    TrackReachedStart = 4,
600    TrackPosChanged = 5,
601    BattStatusChanged = 6,
602    SystemStatusChanged = 7,
603    PlayerApplicationSettingChanged = 8,
604    NowPlayingContentChanged = 9,
605    AvailablePlayersChanged = 10,
606    AddressedPlayerChanged = 11,
607    UidsChanged = 12,
608    VolumeChanged = 13,
609}
610
611impl NotificationEvent {
612    #[inline]
613    pub fn from_primitive(prim: u8) -> Option<Self> {
614        match prim {
615            1 => Some(Self::PlaybackStatusChanged),
616            2 => Some(Self::TrackChanged),
617            3 => Some(Self::TrackReachedEnd),
618            4 => Some(Self::TrackReachedStart),
619            5 => Some(Self::TrackPosChanged),
620            6 => Some(Self::BattStatusChanged),
621            7 => Some(Self::SystemStatusChanged),
622            8 => Some(Self::PlayerApplicationSettingChanged),
623            9 => Some(Self::NowPlayingContentChanged),
624            10 => Some(Self::AvailablePlayersChanged),
625            11 => Some(Self::AddressedPlayerChanged),
626            12 => Some(Self::UidsChanged),
627            13 => Some(Self::VolumeChanged),
628            _ => None,
629        }
630    }
631
632    #[inline]
633    pub const fn into_primitive(self) -> u8 {
634        self as u8
635    }
636}
637
638/// Defined by AVRCP 1.6.2 section 6.7.2 (RegisterNotification).
639/// Format for `EVENT_PLAYBACK_STATUS_CHANGED`.
640#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
641#[repr(u8)]
642pub enum PlaybackStatus {
643    Stopped = 0,
644    Playing = 1,
645    Paused = 2,
646    FwdSeek = 3,
647    RevSeek = 4,
648    Error = 255,
649}
650
651impl PlaybackStatus {
652    #[inline]
653    pub fn from_primitive(prim: u8) -> Option<Self> {
654        match prim {
655            0 => Some(Self::Stopped),
656            1 => Some(Self::Playing),
657            2 => Some(Self::Paused),
658            3 => Some(Self::FwdSeek),
659            4 => Some(Self::RevSeek),
660            255 => Some(Self::Error),
661            _ => None,
662        }
663    }
664
665    #[inline]
666    pub const fn into_primitive(self) -> u8 {
667        self as u8
668    }
669}
670
671/// 0x80 - 0xFF is reserved for custom player application settings.
672/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
673#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
674#[repr(u8)]
675pub enum PlayerApplicationSettingAttributeId {
676    Equalizer = 1,
677    RepeatStatusMode = 2,
678    ShuffleMode = 3,
679    ScanMode = 4,
680}
681
682impl PlayerApplicationSettingAttributeId {
683    #[inline]
684    pub fn from_primitive(prim: u8) -> Option<Self> {
685        match prim {
686            1 => Some(Self::Equalizer),
687            2 => Some(Self::RepeatStatusMode),
688            3 => Some(Self::ShuffleMode),
689            4 => Some(Self::ScanMode),
690            _ => None,
691        }
692    }
693
694    #[inline]
695    pub const fn into_primitive(self) -> u8 {
696        self as u8
697    }
698}
699
700/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
701#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
702#[repr(u8)]
703pub enum RepeatStatusMode {
704    Off = 1,
705    SingleTrackRepeat = 2,
706    AllTrackRepeat = 3,
707    GroupRepeat = 4,
708}
709
710impl RepeatStatusMode {
711    #[inline]
712    pub fn from_primitive(prim: u8) -> Option<Self> {
713        match prim {
714            1 => Some(Self::Off),
715            2 => Some(Self::SingleTrackRepeat),
716            3 => Some(Self::AllTrackRepeat),
717            4 => Some(Self::GroupRepeat),
718            _ => None,
719        }
720    }
721
722    #[inline]
723    pub const fn into_primitive(self) -> u8 {
724        self as u8
725    }
726}
727
728/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
729#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
730#[repr(u8)]
731pub enum ScanMode {
732    Off = 1,
733    AllTrackScan = 2,
734    GroupScan = 3,
735}
736
737impl ScanMode {
738    #[inline]
739    pub fn from_primitive(prim: u8) -> Option<Self> {
740        match prim {
741            1 => Some(Self::Off),
742            2 => Some(Self::AllTrackScan),
743            3 => Some(Self::GroupScan),
744            _ => None,
745        }
746    }
747
748    #[inline]
749    pub const fn into_primitive(self) -> u8 {
750        self as u8
751    }
752}
753
754/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
755#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
756#[repr(u8)]
757pub enum ShuffleMode {
758    Off = 1,
759    AllTrackShuffle = 2,
760    GroupShuffle = 3,
761}
762
763impl ShuffleMode {
764    #[inline]
765    pub fn from_primitive(prim: u8) -> Option<Self> {
766        match prim {
767            1 => Some(Self::Off),
768            2 => Some(Self::AllTrackShuffle),
769            3 => Some(Self::GroupShuffle),
770            _ => None,
771        }
772    }
773
774    #[inline]
775    pub const fn into_primitive(self) -> u8 {
776        self as u8
777    }
778}
779
780/// Defined by AVRCP 1.6.2 section 6.7.2 (RegisterNotification).
781/// Format for `EVENT_SYSTEM_STATUS_CHANGED`.
782#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
783#[repr(u8)]
784pub enum SystemStatus {
785    PowerOn = 0,
786    PowerOff = 1,
787    Unplugged = 2,
788}
789
790impl SystemStatus {
791    #[inline]
792    pub fn from_primitive(prim: u8) -> Option<Self> {
793        match prim {
794            0 => Some(Self::PowerOn),
795            1 => Some(Self::PowerOff),
796            2 => Some(Self::Unplugged),
797            _ => None,
798        }
799    }
800
801    #[inline]
802    pub const fn into_primitive(self) -> u8 {
803        self as u8
804    }
805}
806
807/// Status codes for AVRCP specific AV/C commands.
808/// Defined in AVRCP 1.6.2 section 6.15.3, Table 6.49.
809/// Style note: named exactly as they are in Table 6.49 with the "REJECTED_" prefix.
810#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
811#[repr(u32)]
812pub enum TargetAvcError {
813    RejectedInvalidCommand = 0,
814    RejectedInvalidParameter = 1,
815    RejectedParameterContentError = 2,
816    RejectedInternalError = 3,
817    RejectedUidChanged = 5,
818    RejectedInvalidPlayerId = 17,
819    RejectedNoAvailablePlayers = 21,
820    RejectedAddressedPlayerChanged = 22,
821}
822
823impl TargetAvcError {
824    #[inline]
825    pub fn from_primitive(prim: u32) -> Option<Self> {
826        match prim {
827            0 => Some(Self::RejectedInvalidCommand),
828            1 => Some(Self::RejectedInvalidParameter),
829            2 => Some(Self::RejectedParameterContentError),
830            3 => Some(Self::RejectedInternalError),
831            5 => Some(Self::RejectedUidChanged),
832            17 => Some(Self::RejectedInvalidPlayerId),
833            21 => Some(Self::RejectedNoAvailablePlayers),
834            22 => Some(Self::RejectedAddressedPlayerChanged),
835            _ => None,
836        }
837    }
838
839    #[inline]
840    pub const fn into_primitive(self) -> u32 {
841        self as u32
842    }
843}
844
845/// Status codes for passthrough responses received from the target.
846#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
847#[repr(u32)]
848pub enum TargetPassthroughError {
849    CommandNotImplemented = 1,
850    CommandRejected = 2,
851}
852
853impl TargetPassthroughError {
854    #[inline]
855    pub fn from_primitive(prim: u32) -> Option<Self> {
856        match prim {
857            1 => Some(Self::CommandNotImplemented),
858            2 => Some(Self::CommandRejected),
859            _ => None,
860        }
861    }
862
863    #[inline]
864    pub const fn into_primitive(self) -> u32 {
865        self as u32
866    }
867}
868
869#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
870#[repr(C)]
871pub struct AbsoluteVolumeHandlerGetCurrentVolumeResponse {
872    pub volume: u8,
873}
874
875impl fidl::Persistable for AbsoluteVolumeHandlerGetCurrentVolumeResponse {}
876
877#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
878#[repr(C)]
879pub struct AbsoluteVolumeHandlerOnVolumeChangedResponse {
880    pub new_volume: u8,
881}
882
883impl fidl::Persistable for AbsoluteVolumeHandlerOnVolumeChangedResponse {}
884
885#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
886#[repr(C)]
887pub struct AbsoluteVolumeHandlerSetVolumeRequest {
888    pub requested_volume: u8,
889}
890
891impl fidl::Persistable for AbsoluteVolumeHandlerSetVolumeRequest {}
892
893#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
894#[repr(C)]
895pub struct AbsoluteVolumeHandlerSetVolumeResponse {
896    pub set_volume: u8,
897}
898
899impl fidl::Persistable for AbsoluteVolumeHandlerSetVolumeResponse {}
900
901/// The `AddressedPlayerId` is a unique identifier, assigned by AVRCP, for a media player.
902/// This ID is only used for AVRCP purposes, and should not be interpreted as an
903/// identification created, assigned, or used by MediaSession or any other API surfaces.
904///
905/// Defined in AVRCP 1.6, Section 6.10.2.1.
906#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
907#[repr(C)]
908pub struct AddressedPlayerId {
909    pub id: u16,
910}
911
912impl fidl::Persistable for AddressedPlayerId {}
913
914#[derive(Clone, Debug, PartialEq)]
915pub struct BrowseControllerChangePathRequest {
916    pub path: Path,
917}
918
919impl fidl::Persistable for BrowseControllerChangePathRequest {}
920
921#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
922pub struct BrowseControllerGetFileSystemItemsRequest {
923    pub start_index: u32,
924    pub end_index: u32,
925    pub attribute_option: AttributeRequestOption,
926}
927
928impl fidl::Persistable for BrowseControllerGetFileSystemItemsRequest {}
929
930#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
931#[repr(C)]
932pub struct BrowseControllerGetMediaPlayerItemsRequest {
933    pub start_index: u32,
934    pub end_index: u32,
935}
936
937impl fidl::Persistable for BrowseControllerGetMediaPlayerItemsRequest {}
938
939#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
940pub struct BrowseControllerGetNowPlayingItemsRequest {
941    pub start_index: u32,
942    pub end_index: u32,
943    pub attribute_option: AttributeRequestOption,
944}
945
946impl fidl::Persistable for BrowseControllerGetNowPlayingItemsRequest {}
947
948#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
949#[repr(C)]
950pub struct BrowseControllerPlayFileSystemItemRequest {
951    /// UID of folder or media element.
952    pub uid: u64,
953}
954
955impl fidl::Persistable for BrowseControllerPlayFileSystemItemRequest {}
956
957#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
958#[repr(C)]
959pub struct BrowseControllerPlayNowPlayingItemRequest {
960    pub uid: u64,
961}
962
963impl fidl::Persistable for BrowseControllerPlayNowPlayingItemRequest {}
964
965#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
966#[repr(C)]
967pub struct BrowseControllerSetBrowsedPlayerRequest {
968    pub player_id: u16,
969}
970
971impl fidl::Persistable for BrowseControllerSetBrowsedPlayerRequest {}
972
973#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
974#[repr(C)]
975pub struct BrowseControllerChangePathResponse {
976    pub num_items: u32,
977}
978
979impl fidl::Persistable for BrowseControllerChangePathResponse {}
980
981#[derive(Clone, Debug, PartialEq)]
982pub struct BrowseControllerGetFileSystemItemsResponse {
983    pub items: Vec<FileSystemItem>,
984}
985
986impl fidl::Persistable for BrowseControllerGetFileSystemItemsResponse {}
987
988#[derive(Clone, Debug, PartialEq)]
989pub struct BrowseControllerGetMediaPlayerItemsResponse {
990    pub items: Vec<MediaPlayerItem>,
991}
992
993impl fidl::Persistable for BrowseControllerGetMediaPlayerItemsResponse {}
994
995#[derive(Clone, Debug, PartialEq)]
996pub struct BrowseControllerGetNowPlayingItemsResponse {
997    pub items: Vec<MediaElementItem>,
998}
999
1000impl fidl::Persistable for BrowseControllerGetNowPlayingItemsResponse {}
1001
1002#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1003pub struct ControllerGetPlayerApplicationSettingsRequest {
1004    pub attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
1005}
1006
1007impl fidl::Persistable for ControllerGetPlayerApplicationSettingsRequest {}
1008
1009#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1010pub struct ControllerInformBatteryStatusRequest {
1011    pub battery_status: BatteryStatus,
1012}
1013
1014impl fidl::Persistable for ControllerInformBatteryStatusRequest {}
1015
1016#[derive(Clone, Debug, PartialEq)]
1017pub struct ControllerOnNotificationRequest {
1018    pub timestamp: i64,
1019    pub notification: Notification,
1020}
1021
1022impl fidl::Persistable for ControllerOnNotificationRequest {}
1023
1024#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1025pub struct ControllerSendCommandRequest {
1026    pub command: AvcPanelCommand,
1027}
1028
1029impl fidl::Persistable for ControllerSendCommandRequest {}
1030
1031#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1032#[repr(C)]
1033pub struct ControllerSetAbsoluteVolumeRequest {
1034    pub requested_volume: u8,
1035}
1036
1037impl fidl::Persistable for ControllerSetAbsoluteVolumeRequest {}
1038
1039#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1040#[repr(C)]
1041pub struct ControllerSetAddressedPlayerRequest {
1042    pub player_id: u16,
1043}
1044
1045impl fidl::Persistable for ControllerSetAddressedPlayerRequest {}
1046
1047#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1048pub struct ControllerSetNotificationFilterRequest {
1049    pub notifications: Notifications,
1050    pub position_change_interval: u32,
1051}
1052
1053impl fidl::Persistable for ControllerSetNotificationFilterRequest {}
1054
1055#[derive(Clone, Debug, PartialEq)]
1056pub struct ControllerSetPlayerApplicationSettingsRequest {
1057    pub requested_settings: PlayerApplicationSettings,
1058}
1059
1060impl fidl::Persistable for ControllerSetPlayerApplicationSettingsRequest {}
1061
1062#[derive(Clone, Debug, PartialEq)]
1063pub struct ControllerGetMediaAttributesResponse {
1064    pub attributes: MediaAttributes,
1065}
1066
1067impl fidl::Persistable for ControllerGetMediaAttributesResponse {}
1068
1069#[derive(Clone, Debug, PartialEq)]
1070pub struct ControllerGetPlayStatusResponse {
1071    pub play_status: PlayStatus,
1072}
1073
1074impl fidl::Persistable for ControllerGetPlayStatusResponse {}
1075
1076#[derive(Clone, Debug, PartialEq)]
1077pub struct ControllerGetPlayerApplicationSettingsResponse {
1078    pub current_settings: PlayerApplicationSettings,
1079}
1080
1081impl fidl::Persistable for ControllerGetPlayerApplicationSettingsResponse {}
1082
1083#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1084#[repr(C)]
1085pub struct ControllerSetAbsoluteVolumeResponse {
1086    pub set_volume: u8,
1087}
1088
1089impl fidl::Persistable for ControllerSetAbsoluteVolumeResponse {}
1090
1091#[derive(Clone, Debug, PartialEq)]
1092pub struct ControllerSetPlayerApplicationSettingsResponse {
1093    pub set_settings: PlayerApplicationSettings,
1094}
1095
1096impl fidl::Persistable for ControllerSetPlayerApplicationSettingsResponse {}
1097
1098/// The custom attribute value and its description.
1099#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1100pub struct CustomAttributeValue {
1101    pub description: String,
1102    pub value: u8,
1103}
1104
1105impl fidl::Persistable for CustomAttributeValue {}
1106
1107#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1108pub struct Parent;
1109
1110impl fidl::Persistable for Parent {}
1111
1112#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1113pub struct TargetHandlerGetNotificationRequest {
1114    pub event_id: NotificationEvent,
1115}
1116
1117impl fidl::Persistable for TargetHandlerGetNotificationRequest {}
1118
1119#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1120pub struct TargetHandlerGetPlayerApplicationSettingsRequest {
1121    pub attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
1122}
1123
1124impl fidl::Persistable for TargetHandlerGetPlayerApplicationSettingsRequest {}
1125
1126#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1127pub struct TargetHandlerSendCommandRequest {
1128    pub command: AvcPanelCommand,
1129    pub pressed: bool,
1130}
1131
1132impl fidl::Persistable for TargetHandlerSendCommandRequest {}
1133
1134#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1135#[repr(C)]
1136pub struct TargetHandlerSetAddressedPlayerRequest {
1137    pub player_id: AddressedPlayerId,
1138}
1139
1140impl fidl::Persistable for TargetHandlerSetAddressedPlayerRequest {}
1141
1142#[derive(Clone, Debug, PartialEq)]
1143pub struct TargetHandlerSetPlayerApplicationSettingsRequest {
1144    pub requested_settings: PlayerApplicationSettings,
1145}
1146
1147impl fidl::Persistable for TargetHandlerSetPlayerApplicationSettingsRequest {}
1148
1149#[derive(Clone, Debug, PartialEq)]
1150pub struct TargetHandlerWatchNotificationRequest {
1151    pub event_id: NotificationEvent,
1152    pub current: Notification,
1153    pub pos_change_interval: u32,
1154}
1155
1156impl fidl::Persistable for TargetHandlerWatchNotificationRequest {}
1157
1158#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1159pub struct TargetHandlerGetEventsSupportedResponse {
1160    pub notification_ids: Vec<NotificationEvent>,
1161}
1162
1163impl fidl::Persistable for TargetHandlerGetEventsSupportedResponse {}
1164
1165#[derive(Clone, Debug, PartialEq)]
1166pub struct TargetHandlerGetMediaAttributesResponse {
1167    pub attributes: MediaAttributes,
1168}
1169
1170impl fidl::Persistable for TargetHandlerGetMediaAttributesResponse {}
1171
1172#[derive(Clone, Debug, PartialEq)]
1173pub struct TargetHandlerGetMediaPlayerItemsResponse {
1174    pub items: Vec<MediaPlayerItem>,
1175}
1176
1177impl fidl::Persistable for TargetHandlerGetMediaPlayerItemsResponse {}
1178
1179#[derive(Clone, Debug, PartialEq)]
1180pub struct TargetHandlerGetNotificationResponse {
1181    pub current_value: Notification,
1182}
1183
1184impl fidl::Persistable for TargetHandlerGetNotificationResponse {}
1185
1186#[derive(Clone, Debug, PartialEq)]
1187pub struct TargetHandlerGetPlayStatusResponse {
1188    pub play_status: PlayStatus,
1189}
1190
1191impl fidl::Persistable for TargetHandlerGetPlayStatusResponse {}
1192
1193#[derive(Clone, Debug, PartialEq)]
1194pub struct TargetHandlerGetPlayerApplicationSettingsResponse {
1195    pub current_settings: PlayerApplicationSettings,
1196}
1197
1198impl fidl::Persistable for TargetHandlerGetPlayerApplicationSettingsResponse {}
1199
1200#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1201pub struct TargetHandlerListPlayerApplicationSettingAttributesResponse {
1202    pub attributes: Vec<PlayerApplicationSettingAttributeId>,
1203}
1204
1205impl fidl::Persistable for TargetHandlerListPlayerApplicationSettingAttributesResponse {}
1206
1207#[derive(Clone, Debug, PartialEq)]
1208pub struct TargetHandlerSetPlayerApplicationSettingsResponse {
1209    pub set_settings: PlayerApplicationSettings,
1210}
1211
1212impl fidl::Persistable for TargetHandlerSetPlayerApplicationSettingsResponse {}
1213
1214#[derive(Clone, Debug, PartialEq)]
1215pub struct TargetHandlerWatchNotificationResponse {
1216    pub new_value: Notification,
1217}
1218
1219impl fidl::Persistable for TargetHandlerWatchNotificationResponse {}
1220
1221/// Specification allowed player application settings.
1222/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
1223#[derive(Clone, Debug, Default, PartialEq)]
1224pub struct CustomPlayerApplicationSetting {
1225    /// The attribute id for the custom setting. Must be between 0x80-0xFF, as
1226    /// defined in AVRCP 1.6.2 Appendix F.
1227    pub attribute_id: Option<u8>,
1228    /// The string descriptor of the custom attribute.
1229    pub attribute_name: Option<String>,
1230    /// The possible values the custom attribute can take.
1231    pub possible_values: Option<Vec<CustomAttributeValue>>,
1232    /// The current value that the custom setting is set to.
1233    pub current_value: Option<u8>,
1234    #[doc(hidden)]
1235    pub __source_breaking: fidl::marker::SourceBreaking,
1236}
1237
1238impl fidl::Persistable for CustomPlayerApplicationSetting {}
1239
1240/// Response data for a browseable folder item.
1241/// Defined by AVRCP 1.6.2 section 6.10.2.2.
1242#[derive(Clone, Debug, Default, PartialEq)]
1243pub struct FolderItem {
1244    pub folder_uid: Option<u64>,
1245    pub folder_type: Option<FolderType>,
1246    pub is_playable: Option<bool>,
1247    pub displayable_name: Option<String>,
1248    #[doc(hidden)]
1249    pub __source_breaking: fidl::marker::SourceBreaking,
1250}
1251
1252impl fidl::Persistable for FolderItem {}
1253
1254/// Defined by AVRCP 1.6.2 Appendix E (media attributes).
1255#[derive(Clone, Debug, Default, PartialEq)]
1256pub struct MediaAttributes {
1257    /// The title, song name, or content description.
1258    pub title: Option<String>,
1259    /// The artist, performer, or group.
1260    pub artist_name: Option<String>,
1261    /// The title of the source of media.
1262    pub album_name: Option<String>,
1263    /// The order number of the media on its original recording.
1264    pub track_number: Option<String>,
1265    /// The total number of tracks in the media.
1266    pub total_number_of_tracks: Option<String>,
1267    /// The category of composition of the media,
1268    pub genre: Option<String>,
1269    /// The length of the media in milliseconds (ms).
1270    pub playing_time: Option<String>,
1271    #[doc(hidden)]
1272    pub __source_breaking: fidl::marker::SourceBreaking,
1273}
1274
1275impl fidl::Persistable for MediaAttributes {}
1276
1277/// Response data for a browseable media element item.
1278/// Defined by AVRCP 1.6.2 section 6.10.2.3.
1279#[derive(Clone, Debug, Default, PartialEq)]
1280pub struct MediaElementItem {
1281    pub media_element_uid: Option<u64>,
1282    pub media_type: Option<MediaType>,
1283    pub displayable_name: Option<String>,
1284    pub attributes: Option<MediaAttributes>,
1285    #[doc(hidden)]
1286    pub __source_breaking: fidl::marker::SourceBreaking,
1287}
1288
1289impl fidl::Persistable for MediaElementItem {}
1290
1291/// Response data for the browseable items associated with a media player.
1292/// Defined by AVRCP 1.6.2 section 6.10.2.1.
1293#[derive(Clone, Debug, Default, PartialEq)]
1294pub struct MediaPlayerItem {
1295    pub player_id: Option<u16>,
1296    pub major_type: Option<MajorPlayerType>,
1297    pub sub_type: Option<PlayerSubType>,
1298    pub playback_status: Option<PlaybackStatus>,
1299    pub displayable_name: Option<String>,
1300    pub feature_bits: Option<PlayerFeatureBits>,
1301    pub feature_bits_ext: Option<PlayerFeatureBitsExt>,
1302    #[doc(hidden)]
1303    pub __source_breaking: fidl::marker::SourceBreaking,
1304}
1305
1306impl fidl::Persistable for MediaPlayerItem {}
1307
1308/// Event data from incoming target notifications.
1309/// Defined by AVRCP 1.6.2 Sec 6.7.2.
1310#[derive(Clone, Debug, Default, PartialEq)]
1311pub struct Notification {
1312    /// `EVENT_PLAYBACK_STATUS_CHANGED` event data
1313    pub status: Option<PlaybackStatus>,
1314    /// `EVENT_TRACK_CHANGED` event data
1315    pub track_id: Option<u64>,
1316    /// `EVENT_TRACK_POS_CHANGED` event data
1317    pub pos: Option<u32>,
1318    /// `EVENT_BATT_STATUS_CHANGED` event data
1319    pub battery_status: Option<BatteryStatus>,
1320    /// `EVENT_SYSTEM_STATUS_CHANGED` event data
1321    pub system_status: Option<SystemStatus>,
1322    /// `EVENT_PLAYER_APPLICATION_SETTINGS_CHANGED` event data
1323    pub application_settings: Option<PlayerApplicationSettings>,
1324    /// `EVENT_ADDRESSED_PLAYER_CHANGED` event data
1325    pub player_id: Option<u16>,
1326    /// `EVENT_VOLUME_CHANGED` event data
1327    pub volume: Option<u8>,
1328    /// `CONNECTION_CHANGE` event data
1329    pub device_connected: Option<bool>,
1330    /// `AVAILABLE_PLAYERS_CHANGED` event data
1331    pub available_players_changed: Option<bool>,
1332    /// `ADDRESSED_PLAYER_CHANGED` event data
1333    pub addressed_player: Option<u16>,
1334    #[doc(hidden)]
1335    pub __source_breaking: fidl::marker::SourceBreaking,
1336}
1337
1338impl fidl::Persistable for Notification {}
1339
1340/// Status of currently playing media on the TG.
1341/// Defined by AVRCP 1.6.2 section 6.7.1, Table 6.29.
1342#[derive(Clone, Debug, Default, PartialEq)]
1343pub struct PlayStatus {
1344    /// The total length of the currently playing media, in milliseconds.
1345    /// Optional, if the TG does not support song length.
1346    pub song_length: Option<u32>,
1347    /// The current position of the playing media, in milliseconds elapsed.
1348    /// Optional, if the TG does not support song position.
1349    pub song_position: Option<u32>,
1350    /// The playback status of the currently playing media.
1351    /// Mandatory, the TG must respond with a PlaybackStatus.
1352    pub playback_status: Option<PlaybackStatus>,
1353    #[doc(hidden)]
1354    pub __source_breaking: fidl::marker::SourceBreaking,
1355}
1356
1357impl fidl::Persistable for PlayStatus {}
1358
1359/// Defined by AVRCP 1.6.2 Appendix F (player application settings).
1360#[derive(Clone, Debug, Default, PartialEq)]
1361pub struct PlayerApplicationSettings {
1362    /// The equalizer status of the remote target.
1363    pub equalizer: Option<Equalizer>,
1364    /// The repeat mode status of the remote target.
1365    pub repeat_status_mode: Option<RepeatStatusMode>,
1366    /// The shuffle mode status of the remote target.
1367    pub shuffle_mode: Option<ShuffleMode>,
1368    /// The scan mode status of the remote target.
1369    pub scan_mode: Option<ScanMode>,
1370    /// Custom settings that are specification allowed.
1371    pub custom_settings: Option<Vec<CustomPlayerApplicationSetting>>,
1372    #[doc(hidden)]
1373    pub __source_breaking: fidl::marker::SourceBreaking,
1374}
1375
1376impl fidl::Persistable for PlayerApplicationSettings {}
1377
1378/// Set `get_all` if we want all attributes of a media element item.
1379/// Set `attribute_list` if we want to get only the specified attributes.
1380/// If `get_all` is set to false, it will be treated as attribute request
1381/// with emtpy list of attribute IDs.
1382#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1383pub enum AttributeRequestOption {
1384    GetAll(bool),
1385    AttributeList(Vec<MediaAttributeId>),
1386}
1387
1388impl AttributeRequestOption {
1389    #[inline]
1390    pub fn ordinal(&self) -> u64 {
1391        match *self {
1392            Self::GetAll(_) => 1,
1393            Self::AttributeList(_) => 2,
1394        }
1395    }
1396}
1397
1398impl fidl::Persistable for AttributeRequestOption {}
1399
1400/// Items returned from GetFolderItems(Filesystem) may be either a folder or media element.
1401/// Defined by AVRCP 1.6.2 section 6.10.1.2.
1402/// Only one of `folder` or `media_element` should be set.
1403#[derive(Clone, Debug, PartialEq)]
1404pub enum FileSystemItem {
1405    Folder(FolderItem),
1406    MediaElement(MediaElementItem),
1407}
1408
1409impl FileSystemItem {
1410    #[inline]
1411    pub fn ordinal(&self) -> u64 {
1412        match *self {
1413            Self::Folder(_) => 1,
1414            Self::MediaElement(_) => 2,
1415        }
1416    }
1417}
1418
1419impl fidl::Persistable for FileSystemItem {}
1420
1421/// Relative path from the current directory.
1422/// As per AVRCP 1.6.2 Section 6.10.4.1.1, it either specifies a parent folder
1423/// for Folder Up direction or a child folder by its unique ID for Folder
1424/// Down direction.
1425#[derive(Clone, Debug)]
1426pub enum Path {
1427    Parent(Parent),
1428    ChildFolderUid(u64),
1429    #[doc(hidden)]
1430    __SourceBreaking {
1431        unknown_ordinal: u64,
1432    },
1433}
1434
1435/// Pattern that matches an unknown `Path` member.
1436#[macro_export]
1437macro_rules! PathUnknown {
1438    () => {
1439        _
1440    };
1441}
1442
1443// Custom PartialEq so that unknown variants are not equal to themselves.
1444impl PartialEq for Path {
1445    fn eq(&self, other: &Self) -> bool {
1446        match (self, other) {
1447            (Self::Parent(x), Self::Parent(y)) => *x == *y,
1448            (Self::ChildFolderUid(x), Self::ChildFolderUid(y)) => *x == *y,
1449            _ => false,
1450        }
1451    }
1452}
1453
1454impl Path {
1455    #[inline]
1456    pub fn ordinal(&self) -> u64 {
1457        match *self {
1458            Self::Parent(_) => 1,
1459            Self::ChildFolderUid(_) => 2,
1460            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1461        }
1462    }
1463
1464    #[inline]
1465    pub fn unknown_variant_for_testing() -> Self {
1466        Self::__SourceBreaking { unknown_ordinal: 0 }
1467    }
1468
1469    #[inline]
1470    pub fn is_unknown(&self) -> bool {
1471        match self {
1472            Self::__SourceBreaking { .. } => true,
1473            _ => false,
1474        }
1475    }
1476}
1477
1478impl fidl::Persistable for Path {}
1479
1480mod internal {
1481    use super::*;
1482    unsafe impl fidl::encoding::TypeMarker for MajorPlayerType {
1483        type Owned = Self;
1484
1485        #[inline(always)]
1486        fn inline_align(_context: fidl::encoding::Context) -> usize {
1487            1
1488        }
1489
1490        #[inline(always)]
1491        fn inline_size(_context: fidl::encoding::Context) -> usize {
1492            1
1493        }
1494    }
1495
1496    impl fidl::encoding::ValueTypeMarker for MajorPlayerType {
1497        type Borrowed<'a> = Self;
1498        #[inline(always)]
1499        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1500            *value
1501        }
1502    }
1503
1504    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1505        for MajorPlayerType
1506    {
1507        #[inline]
1508        unsafe fn encode(
1509            self,
1510            encoder: &mut fidl::encoding::Encoder<'_, D>,
1511            offset: usize,
1512            _depth: fidl::encoding::Depth,
1513        ) -> fidl::Result<()> {
1514            encoder.debug_check_bounds::<Self>(offset);
1515            if self.bits() & Self::all().bits() != self.bits() {
1516                return Err(fidl::Error::InvalidBitsValue);
1517            }
1518            encoder.write_num(self.bits(), offset);
1519            Ok(())
1520        }
1521    }
1522
1523    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MajorPlayerType {
1524        #[inline(always)]
1525        fn new_empty() -> Self {
1526            Self::empty()
1527        }
1528
1529        #[inline]
1530        unsafe fn decode(
1531            &mut self,
1532            decoder: &mut fidl::encoding::Decoder<'_, D>,
1533            offset: usize,
1534            _depth: fidl::encoding::Depth,
1535        ) -> fidl::Result<()> {
1536            decoder.debug_check_bounds::<Self>(offset);
1537            let prim = decoder.read_num::<u8>(offset);
1538            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1539            Ok(())
1540        }
1541    }
1542    unsafe impl fidl::encoding::TypeMarker for Notifications {
1543        type Owned = Self;
1544
1545        #[inline(always)]
1546        fn inline_align(_context: fidl::encoding::Context) -> usize {
1547            4
1548        }
1549
1550        #[inline(always)]
1551        fn inline_size(_context: fidl::encoding::Context) -> usize {
1552            4
1553        }
1554    }
1555
1556    impl fidl::encoding::ValueTypeMarker for Notifications {
1557        type Borrowed<'a> = Self;
1558        #[inline(always)]
1559        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1560            *value
1561        }
1562    }
1563
1564    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Notifications {
1565        #[inline]
1566        unsafe fn encode(
1567            self,
1568            encoder: &mut fidl::encoding::Encoder<'_, D>,
1569            offset: usize,
1570            _depth: fidl::encoding::Depth,
1571        ) -> fidl::Result<()> {
1572            encoder.debug_check_bounds::<Self>(offset);
1573            if self.bits() & Self::all().bits() != self.bits() {
1574                return Err(fidl::Error::InvalidBitsValue);
1575            }
1576            encoder.write_num(self.bits(), offset);
1577            Ok(())
1578        }
1579    }
1580
1581    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notifications {
1582        #[inline(always)]
1583        fn new_empty() -> Self {
1584            Self::empty()
1585        }
1586
1587        #[inline]
1588        unsafe fn decode(
1589            &mut self,
1590            decoder: &mut fidl::encoding::Decoder<'_, D>,
1591            offset: usize,
1592            _depth: fidl::encoding::Depth,
1593        ) -> fidl::Result<()> {
1594            decoder.debug_check_bounds::<Self>(offset);
1595            let prim = decoder.read_num::<u32>(offset);
1596            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1597            Ok(())
1598        }
1599    }
1600    unsafe impl fidl::encoding::TypeMarker for PlayerFeatureBits {
1601        type Owned = Self;
1602
1603        #[inline(always)]
1604        fn inline_align(_context: fidl::encoding::Context) -> usize {
1605            8
1606        }
1607
1608        #[inline(always)]
1609        fn inline_size(_context: fidl::encoding::Context) -> usize {
1610            8
1611        }
1612    }
1613
1614    impl fidl::encoding::ValueTypeMarker for PlayerFeatureBits {
1615        type Borrowed<'a> = Self;
1616        #[inline(always)]
1617        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1618            *value
1619        }
1620    }
1621
1622    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1623        for PlayerFeatureBits
1624    {
1625        #[inline]
1626        unsafe fn encode(
1627            self,
1628            encoder: &mut fidl::encoding::Encoder<'_, D>,
1629            offset: usize,
1630            _depth: fidl::encoding::Depth,
1631        ) -> fidl::Result<()> {
1632            encoder.debug_check_bounds::<Self>(offset);
1633            if self.bits() & Self::all().bits() != self.bits() {
1634                return Err(fidl::Error::InvalidBitsValue);
1635            }
1636            encoder.write_num(self.bits(), offset);
1637            Ok(())
1638        }
1639    }
1640
1641    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerFeatureBits {
1642        #[inline(always)]
1643        fn new_empty() -> Self {
1644            Self::empty()
1645        }
1646
1647        #[inline]
1648        unsafe fn decode(
1649            &mut self,
1650            decoder: &mut fidl::encoding::Decoder<'_, D>,
1651            offset: usize,
1652            _depth: fidl::encoding::Depth,
1653        ) -> fidl::Result<()> {
1654            decoder.debug_check_bounds::<Self>(offset);
1655            let prim = decoder.read_num::<u64>(offset);
1656            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1657            Ok(())
1658        }
1659    }
1660    unsafe impl fidl::encoding::TypeMarker for PlayerFeatureBitsExt {
1661        type Owned = Self;
1662
1663        #[inline(always)]
1664        fn inline_align(_context: fidl::encoding::Context) -> usize {
1665            8
1666        }
1667
1668        #[inline(always)]
1669        fn inline_size(_context: fidl::encoding::Context) -> usize {
1670            8
1671        }
1672    }
1673
1674    impl fidl::encoding::ValueTypeMarker for PlayerFeatureBitsExt {
1675        type Borrowed<'a> = Self;
1676        #[inline(always)]
1677        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1678            *value
1679        }
1680    }
1681
1682    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1683        for PlayerFeatureBitsExt
1684    {
1685        #[inline]
1686        unsafe fn encode(
1687            self,
1688            encoder: &mut fidl::encoding::Encoder<'_, D>,
1689            offset: usize,
1690            _depth: fidl::encoding::Depth,
1691        ) -> fidl::Result<()> {
1692            encoder.debug_check_bounds::<Self>(offset);
1693            if self.bits() & Self::all().bits() != self.bits() {
1694                return Err(fidl::Error::InvalidBitsValue);
1695            }
1696            encoder.write_num(self.bits(), offset);
1697            Ok(())
1698        }
1699    }
1700
1701    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerFeatureBitsExt {
1702        #[inline(always)]
1703        fn new_empty() -> Self {
1704            Self::empty()
1705        }
1706
1707        #[inline]
1708        unsafe fn decode(
1709            &mut self,
1710            decoder: &mut fidl::encoding::Decoder<'_, D>,
1711            offset: usize,
1712            _depth: fidl::encoding::Depth,
1713        ) -> fidl::Result<()> {
1714            decoder.debug_check_bounds::<Self>(offset);
1715            let prim = decoder.read_num::<u64>(offset);
1716            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1717            Ok(())
1718        }
1719    }
1720    unsafe impl fidl::encoding::TypeMarker for PlayerSubType {
1721        type Owned = Self;
1722
1723        #[inline(always)]
1724        fn inline_align(_context: fidl::encoding::Context) -> usize {
1725            4
1726        }
1727
1728        #[inline(always)]
1729        fn inline_size(_context: fidl::encoding::Context) -> usize {
1730            4
1731        }
1732    }
1733
1734    impl fidl::encoding::ValueTypeMarker for PlayerSubType {
1735        type Borrowed<'a> = Self;
1736        #[inline(always)]
1737        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1738            *value
1739        }
1740    }
1741
1742    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlayerSubType {
1743        #[inline]
1744        unsafe fn encode(
1745            self,
1746            encoder: &mut fidl::encoding::Encoder<'_, D>,
1747            offset: usize,
1748            _depth: fidl::encoding::Depth,
1749        ) -> fidl::Result<()> {
1750            encoder.debug_check_bounds::<Self>(offset);
1751            if self.bits() & Self::all().bits() != self.bits() {
1752                return Err(fidl::Error::InvalidBitsValue);
1753            }
1754            encoder.write_num(self.bits(), offset);
1755            Ok(())
1756        }
1757    }
1758
1759    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerSubType {
1760        #[inline(always)]
1761        fn new_empty() -> Self {
1762            Self::empty()
1763        }
1764
1765        #[inline]
1766        unsafe fn decode(
1767            &mut self,
1768            decoder: &mut fidl::encoding::Decoder<'_, D>,
1769            offset: usize,
1770            _depth: fidl::encoding::Depth,
1771        ) -> fidl::Result<()> {
1772            decoder.debug_check_bounds::<Self>(offset);
1773            let prim = decoder.read_num::<u32>(offset);
1774            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1775            Ok(())
1776        }
1777    }
1778    unsafe impl fidl::encoding::TypeMarker for AvcPanelCommand {
1779        type Owned = Self;
1780
1781        #[inline(always)]
1782        fn inline_align(_context: fidl::encoding::Context) -> usize {
1783            std::mem::align_of::<u8>()
1784        }
1785
1786        #[inline(always)]
1787        fn inline_size(_context: fidl::encoding::Context) -> usize {
1788            std::mem::size_of::<u8>()
1789        }
1790
1791        #[inline(always)]
1792        fn encode_is_copy() -> bool {
1793            true
1794        }
1795
1796        #[inline(always)]
1797        fn decode_is_copy() -> bool {
1798            false
1799        }
1800    }
1801
1802    impl fidl::encoding::ValueTypeMarker for AvcPanelCommand {
1803        type Borrowed<'a> = Self;
1804        #[inline(always)]
1805        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1806            *value
1807        }
1808    }
1809
1810    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1811        for AvcPanelCommand
1812    {
1813        #[inline]
1814        unsafe fn encode(
1815            self,
1816            encoder: &mut fidl::encoding::Encoder<'_, D>,
1817            offset: usize,
1818            _depth: fidl::encoding::Depth,
1819        ) -> fidl::Result<()> {
1820            encoder.debug_check_bounds::<Self>(offset);
1821            encoder.write_num(self.into_primitive(), offset);
1822            Ok(())
1823        }
1824    }
1825
1826    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AvcPanelCommand {
1827        #[inline(always)]
1828        fn new_empty() -> Self {
1829            Self::Select
1830        }
1831
1832        #[inline]
1833        unsafe fn decode(
1834            &mut self,
1835            decoder: &mut fidl::encoding::Decoder<'_, D>,
1836            offset: usize,
1837            _depth: fidl::encoding::Depth,
1838        ) -> fidl::Result<()> {
1839            decoder.debug_check_bounds::<Self>(offset);
1840            let prim = decoder.read_num::<u8>(offset);
1841
1842            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1843            Ok(())
1844        }
1845    }
1846    unsafe impl fidl::encoding::TypeMarker for BatteryStatus {
1847        type Owned = Self;
1848
1849        #[inline(always)]
1850        fn inline_align(_context: fidl::encoding::Context) -> usize {
1851            std::mem::align_of::<u8>()
1852        }
1853
1854        #[inline(always)]
1855        fn inline_size(_context: fidl::encoding::Context) -> usize {
1856            std::mem::size_of::<u8>()
1857        }
1858
1859        #[inline(always)]
1860        fn encode_is_copy() -> bool {
1861            true
1862        }
1863
1864        #[inline(always)]
1865        fn decode_is_copy() -> bool {
1866            false
1867        }
1868    }
1869
1870    impl fidl::encoding::ValueTypeMarker for BatteryStatus {
1871        type Borrowed<'a> = Self;
1872        #[inline(always)]
1873        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1874            *value
1875        }
1876    }
1877
1878    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BatteryStatus {
1879        #[inline]
1880        unsafe fn encode(
1881            self,
1882            encoder: &mut fidl::encoding::Encoder<'_, D>,
1883            offset: usize,
1884            _depth: fidl::encoding::Depth,
1885        ) -> fidl::Result<()> {
1886            encoder.debug_check_bounds::<Self>(offset);
1887            encoder.write_num(self.into_primitive(), offset);
1888            Ok(())
1889        }
1890    }
1891
1892    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryStatus {
1893        #[inline(always)]
1894        fn new_empty() -> Self {
1895            Self::Normal
1896        }
1897
1898        #[inline]
1899        unsafe fn decode(
1900            &mut self,
1901            decoder: &mut fidl::encoding::Decoder<'_, D>,
1902            offset: usize,
1903            _depth: fidl::encoding::Depth,
1904        ) -> fidl::Result<()> {
1905            decoder.debug_check_bounds::<Self>(offset);
1906            let prim = decoder.read_num::<u8>(offset);
1907
1908            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1909            Ok(())
1910        }
1911    }
1912    unsafe impl fidl::encoding::TypeMarker for BrowseControllerError {
1913        type Owned = Self;
1914
1915        #[inline(always)]
1916        fn inline_align(_context: fidl::encoding::Context) -> usize {
1917            std::mem::align_of::<u32>()
1918        }
1919
1920        #[inline(always)]
1921        fn inline_size(_context: fidl::encoding::Context) -> usize {
1922            std::mem::size_of::<u32>()
1923        }
1924
1925        #[inline(always)]
1926        fn encode_is_copy() -> bool {
1927            true
1928        }
1929
1930        #[inline(always)]
1931        fn decode_is_copy() -> bool {
1932            false
1933        }
1934    }
1935
1936    impl fidl::encoding::ValueTypeMarker for BrowseControllerError {
1937        type Borrowed<'a> = Self;
1938        #[inline(always)]
1939        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1940            *value
1941        }
1942    }
1943
1944    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1945        for BrowseControllerError
1946    {
1947        #[inline]
1948        unsafe fn encode(
1949            self,
1950            encoder: &mut fidl::encoding::Encoder<'_, D>,
1951            offset: usize,
1952            _depth: fidl::encoding::Depth,
1953        ) -> fidl::Result<()> {
1954            encoder.debug_check_bounds::<Self>(offset);
1955            encoder.write_num(self.into_primitive(), offset);
1956            Ok(())
1957        }
1958    }
1959
1960    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BrowseControllerError {
1961        #[inline(always)]
1962        fn new_empty() -> Self {
1963            Self::UnknownFailure
1964        }
1965
1966        #[inline]
1967        unsafe fn decode(
1968            &mut self,
1969            decoder: &mut fidl::encoding::Decoder<'_, D>,
1970            offset: usize,
1971            _depth: fidl::encoding::Depth,
1972        ) -> fidl::Result<()> {
1973            decoder.debug_check_bounds::<Self>(offset);
1974            let prim = decoder.read_num::<u32>(offset);
1975
1976            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1977            Ok(())
1978        }
1979    }
1980    unsafe impl fidl::encoding::TypeMarker for ControllerError {
1981        type Owned = Self;
1982
1983        #[inline(always)]
1984        fn inline_align(_context: fidl::encoding::Context) -> usize {
1985            std::mem::align_of::<u32>()
1986        }
1987
1988        #[inline(always)]
1989        fn inline_size(_context: fidl::encoding::Context) -> usize {
1990            std::mem::size_of::<u32>()
1991        }
1992
1993        #[inline(always)]
1994        fn encode_is_copy() -> bool {
1995            true
1996        }
1997
1998        #[inline(always)]
1999        fn decode_is_copy() -> bool {
2000            false
2001        }
2002    }
2003
2004    impl fidl::encoding::ValueTypeMarker for ControllerError {
2005        type Borrowed<'a> = Self;
2006        #[inline(always)]
2007        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2008            *value
2009        }
2010    }
2011
2012    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2013        for ControllerError
2014    {
2015        #[inline]
2016        unsafe fn encode(
2017            self,
2018            encoder: &mut fidl::encoding::Encoder<'_, D>,
2019            offset: usize,
2020            _depth: fidl::encoding::Depth,
2021        ) -> fidl::Result<()> {
2022            encoder.debug_check_bounds::<Self>(offset);
2023            encoder.write_num(self.into_primitive(), offset);
2024            Ok(())
2025        }
2026    }
2027
2028    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControllerError {
2029        #[inline(always)]
2030        fn new_empty() -> Self {
2031            Self::UnknownFailure
2032        }
2033
2034        #[inline]
2035        unsafe fn decode(
2036            &mut self,
2037            decoder: &mut fidl::encoding::Decoder<'_, D>,
2038            offset: usize,
2039            _depth: fidl::encoding::Depth,
2040        ) -> fidl::Result<()> {
2041            decoder.debug_check_bounds::<Self>(offset);
2042            let prim = decoder.read_num::<u32>(offset);
2043
2044            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2045            Ok(())
2046        }
2047    }
2048    unsafe impl fidl::encoding::TypeMarker for Equalizer {
2049        type Owned = Self;
2050
2051        #[inline(always)]
2052        fn inline_align(_context: fidl::encoding::Context) -> usize {
2053            std::mem::align_of::<u8>()
2054        }
2055
2056        #[inline(always)]
2057        fn inline_size(_context: fidl::encoding::Context) -> usize {
2058            std::mem::size_of::<u8>()
2059        }
2060
2061        #[inline(always)]
2062        fn encode_is_copy() -> bool {
2063            true
2064        }
2065
2066        #[inline(always)]
2067        fn decode_is_copy() -> bool {
2068            false
2069        }
2070    }
2071
2072    impl fidl::encoding::ValueTypeMarker for Equalizer {
2073        type Borrowed<'a> = Self;
2074        #[inline(always)]
2075        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2076            *value
2077        }
2078    }
2079
2080    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Equalizer {
2081        #[inline]
2082        unsafe fn encode(
2083            self,
2084            encoder: &mut fidl::encoding::Encoder<'_, D>,
2085            offset: usize,
2086            _depth: fidl::encoding::Depth,
2087        ) -> fidl::Result<()> {
2088            encoder.debug_check_bounds::<Self>(offset);
2089            encoder.write_num(self.into_primitive(), offset);
2090            Ok(())
2091        }
2092    }
2093
2094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Equalizer {
2095        #[inline(always)]
2096        fn new_empty() -> Self {
2097            Self::Off
2098        }
2099
2100        #[inline]
2101        unsafe fn decode(
2102            &mut self,
2103            decoder: &mut fidl::encoding::Decoder<'_, D>,
2104            offset: usize,
2105            _depth: fidl::encoding::Depth,
2106        ) -> fidl::Result<()> {
2107            decoder.debug_check_bounds::<Self>(offset);
2108            let prim = decoder.read_num::<u8>(offset);
2109
2110            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2111            Ok(())
2112        }
2113    }
2114    unsafe impl fidl::encoding::TypeMarker for FolderType {
2115        type Owned = Self;
2116
2117        #[inline(always)]
2118        fn inline_align(_context: fidl::encoding::Context) -> usize {
2119            std::mem::align_of::<u8>()
2120        }
2121
2122        #[inline(always)]
2123        fn inline_size(_context: fidl::encoding::Context) -> usize {
2124            std::mem::size_of::<u8>()
2125        }
2126
2127        #[inline(always)]
2128        fn encode_is_copy() -> bool {
2129            true
2130        }
2131
2132        #[inline(always)]
2133        fn decode_is_copy() -> bool {
2134            false
2135        }
2136    }
2137
2138    impl fidl::encoding::ValueTypeMarker for FolderType {
2139        type Borrowed<'a> = Self;
2140        #[inline(always)]
2141        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2142            *value
2143        }
2144    }
2145
2146    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FolderType {
2147        #[inline]
2148        unsafe fn encode(
2149            self,
2150            encoder: &mut fidl::encoding::Encoder<'_, D>,
2151            offset: usize,
2152            _depth: fidl::encoding::Depth,
2153        ) -> fidl::Result<()> {
2154            encoder.debug_check_bounds::<Self>(offset);
2155            encoder.write_num(self.into_primitive(), offset);
2156            Ok(())
2157        }
2158    }
2159
2160    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FolderType {
2161        #[inline(always)]
2162        fn new_empty() -> Self {
2163            Self::Mixed
2164        }
2165
2166        #[inline]
2167        unsafe fn decode(
2168            &mut self,
2169            decoder: &mut fidl::encoding::Decoder<'_, D>,
2170            offset: usize,
2171            _depth: fidl::encoding::Depth,
2172        ) -> fidl::Result<()> {
2173            decoder.debug_check_bounds::<Self>(offset);
2174            let prim = decoder.read_num::<u8>(offset);
2175
2176            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2177            Ok(())
2178        }
2179    }
2180    unsafe impl fidl::encoding::TypeMarker for MediaAttributeId {
2181        type Owned = Self;
2182
2183        #[inline(always)]
2184        fn inline_align(_context: fidl::encoding::Context) -> usize {
2185            std::mem::align_of::<u32>()
2186        }
2187
2188        #[inline(always)]
2189        fn inline_size(_context: fidl::encoding::Context) -> usize {
2190            std::mem::size_of::<u32>()
2191        }
2192
2193        #[inline(always)]
2194        fn encode_is_copy() -> bool {
2195            true
2196        }
2197
2198        #[inline(always)]
2199        fn decode_is_copy() -> bool {
2200            false
2201        }
2202    }
2203
2204    impl fidl::encoding::ValueTypeMarker for MediaAttributeId {
2205        type Borrowed<'a> = Self;
2206        #[inline(always)]
2207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2208            *value
2209        }
2210    }
2211
2212    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2213        for MediaAttributeId
2214    {
2215        #[inline]
2216        unsafe fn encode(
2217            self,
2218            encoder: &mut fidl::encoding::Encoder<'_, D>,
2219            offset: usize,
2220            _depth: fidl::encoding::Depth,
2221        ) -> fidl::Result<()> {
2222            encoder.debug_check_bounds::<Self>(offset);
2223            encoder.write_num(self.into_primitive(), offset);
2224            Ok(())
2225        }
2226    }
2227
2228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaAttributeId {
2229        #[inline(always)]
2230        fn new_empty() -> Self {
2231            Self::Title
2232        }
2233
2234        #[inline]
2235        unsafe fn decode(
2236            &mut self,
2237            decoder: &mut fidl::encoding::Decoder<'_, D>,
2238            offset: usize,
2239            _depth: fidl::encoding::Depth,
2240        ) -> fidl::Result<()> {
2241            decoder.debug_check_bounds::<Self>(offset);
2242            let prim = decoder.read_num::<u32>(offset);
2243
2244            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2245            Ok(())
2246        }
2247    }
2248    unsafe impl fidl::encoding::TypeMarker for MediaType {
2249        type Owned = Self;
2250
2251        #[inline(always)]
2252        fn inline_align(_context: fidl::encoding::Context) -> usize {
2253            std::mem::align_of::<u8>()
2254        }
2255
2256        #[inline(always)]
2257        fn inline_size(_context: fidl::encoding::Context) -> usize {
2258            std::mem::size_of::<u8>()
2259        }
2260
2261        #[inline(always)]
2262        fn encode_is_copy() -> bool {
2263            true
2264        }
2265
2266        #[inline(always)]
2267        fn decode_is_copy() -> bool {
2268            false
2269        }
2270    }
2271
2272    impl fidl::encoding::ValueTypeMarker for MediaType {
2273        type Borrowed<'a> = Self;
2274        #[inline(always)]
2275        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2276            *value
2277        }
2278    }
2279
2280    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MediaType {
2281        #[inline]
2282        unsafe fn encode(
2283            self,
2284            encoder: &mut fidl::encoding::Encoder<'_, D>,
2285            offset: usize,
2286            _depth: fidl::encoding::Depth,
2287        ) -> fidl::Result<()> {
2288            encoder.debug_check_bounds::<Self>(offset);
2289            encoder.write_num(self.into_primitive(), offset);
2290            Ok(())
2291        }
2292    }
2293
2294    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaType {
2295        #[inline(always)]
2296        fn new_empty() -> Self {
2297            Self::Audio
2298        }
2299
2300        #[inline]
2301        unsafe fn decode(
2302            &mut self,
2303            decoder: &mut fidl::encoding::Decoder<'_, D>,
2304            offset: usize,
2305            _depth: fidl::encoding::Depth,
2306        ) -> fidl::Result<()> {
2307            decoder.debug_check_bounds::<Self>(offset);
2308            let prim = decoder.read_num::<u8>(offset);
2309
2310            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2311            Ok(())
2312        }
2313    }
2314    unsafe impl fidl::encoding::TypeMarker for NotificationEvent {
2315        type Owned = Self;
2316
2317        #[inline(always)]
2318        fn inline_align(_context: fidl::encoding::Context) -> usize {
2319            std::mem::align_of::<u8>()
2320        }
2321
2322        #[inline(always)]
2323        fn inline_size(_context: fidl::encoding::Context) -> usize {
2324            std::mem::size_of::<u8>()
2325        }
2326
2327        #[inline(always)]
2328        fn encode_is_copy() -> bool {
2329            true
2330        }
2331
2332        #[inline(always)]
2333        fn decode_is_copy() -> bool {
2334            false
2335        }
2336    }
2337
2338    impl fidl::encoding::ValueTypeMarker for NotificationEvent {
2339        type Borrowed<'a> = Self;
2340        #[inline(always)]
2341        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2342            *value
2343        }
2344    }
2345
2346    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2347        for NotificationEvent
2348    {
2349        #[inline]
2350        unsafe fn encode(
2351            self,
2352            encoder: &mut fidl::encoding::Encoder<'_, D>,
2353            offset: usize,
2354            _depth: fidl::encoding::Depth,
2355        ) -> fidl::Result<()> {
2356            encoder.debug_check_bounds::<Self>(offset);
2357            encoder.write_num(self.into_primitive(), offset);
2358            Ok(())
2359        }
2360    }
2361
2362    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NotificationEvent {
2363        #[inline(always)]
2364        fn new_empty() -> Self {
2365            Self::PlaybackStatusChanged
2366        }
2367
2368        #[inline]
2369        unsafe fn decode(
2370            &mut self,
2371            decoder: &mut fidl::encoding::Decoder<'_, D>,
2372            offset: usize,
2373            _depth: fidl::encoding::Depth,
2374        ) -> fidl::Result<()> {
2375            decoder.debug_check_bounds::<Self>(offset);
2376            let prim = decoder.read_num::<u8>(offset);
2377
2378            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2379            Ok(())
2380        }
2381    }
2382    unsafe impl fidl::encoding::TypeMarker for PlaybackStatus {
2383        type Owned = Self;
2384
2385        #[inline(always)]
2386        fn inline_align(_context: fidl::encoding::Context) -> usize {
2387            std::mem::align_of::<u8>()
2388        }
2389
2390        #[inline(always)]
2391        fn inline_size(_context: fidl::encoding::Context) -> usize {
2392            std::mem::size_of::<u8>()
2393        }
2394
2395        #[inline(always)]
2396        fn encode_is_copy() -> bool {
2397            true
2398        }
2399
2400        #[inline(always)]
2401        fn decode_is_copy() -> bool {
2402            false
2403        }
2404    }
2405
2406    impl fidl::encoding::ValueTypeMarker for PlaybackStatus {
2407        type Borrowed<'a> = Self;
2408        #[inline(always)]
2409        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2410            *value
2411        }
2412    }
2413
2414    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlaybackStatus {
2415        #[inline]
2416        unsafe fn encode(
2417            self,
2418            encoder: &mut fidl::encoding::Encoder<'_, D>,
2419            offset: usize,
2420            _depth: fidl::encoding::Depth,
2421        ) -> fidl::Result<()> {
2422            encoder.debug_check_bounds::<Self>(offset);
2423            encoder.write_num(self.into_primitive(), offset);
2424            Ok(())
2425        }
2426    }
2427
2428    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlaybackStatus {
2429        #[inline(always)]
2430        fn new_empty() -> Self {
2431            Self::Stopped
2432        }
2433
2434        #[inline]
2435        unsafe fn decode(
2436            &mut self,
2437            decoder: &mut fidl::encoding::Decoder<'_, D>,
2438            offset: usize,
2439            _depth: fidl::encoding::Depth,
2440        ) -> fidl::Result<()> {
2441            decoder.debug_check_bounds::<Self>(offset);
2442            let prim = decoder.read_num::<u8>(offset);
2443
2444            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2445            Ok(())
2446        }
2447    }
2448    unsafe impl fidl::encoding::TypeMarker for PlayerApplicationSettingAttributeId {
2449        type Owned = Self;
2450
2451        #[inline(always)]
2452        fn inline_align(_context: fidl::encoding::Context) -> usize {
2453            std::mem::align_of::<u8>()
2454        }
2455
2456        #[inline(always)]
2457        fn inline_size(_context: fidl::encoding::Context) -> usize {
2458            std::mem::size_of::<u8>()
2459        }
2460
2461        #[inline(always)]
2462        fn encode_is_copy() -> bool {
2463            true
2464        }
2465
2466        #[inline(always)]
2467        fn decode_is_copy() -> bool {
2468            false
2469        }
2470    }
2471
2472    impl fidl::encoding::ValueTypeMarker for PlayerApplicationSettingAttributeId {
2473        type Borrowed<'a> = Self;
2474        #[inline(always)]
2475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476            *value
2477        }
2478    }
2479
2480    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2481        for PlayerApplicationSettingAttributeId
2482    {
2483        #[inline]
2484        unsafe fn encode(
2485            self,
2486            encoder: &mut fidl::encoding::Encoder<'_, D>,
2487            offset: usize,
2488            _depth: fidl::encoding::Depth,
2489        ) -> fidl::Result<()> {
2490            encoder.debug_check_bounds::<Self>(offset);
2491            encoder.write_num(self.into_primitive(), offset);
2492            Ok(())
2493        }
2494    }
2495
2496    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2497        for PlayerApplicationSettingAttributeId
2498    {
2499        #[inline(always)]
2500        fn new_empty() -> Self {
2501            Self::Equalizer
2502        }
2503
2504        #[inline]
2505        unsafe fn decode(
2506            &mut self,
2507            decoder: &mut fidl::encoding::Decoder<'_, D>,
2508            offset: usize,
2509            _depth: fidl::encoding::Depth,
2510        ) -> fidl::Result<()> {
2511            decoder.debug_check_bounds::<Self>(offset);
2512            let prim = decoder.read_num::<u8>(offset);
2513
2514            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2515            Ok(())
2516        }
2517    }
2518    unsafe impl fidl::encoding::TypeMarker for RepeatStatusMode {
2519        type Owned = Self;
2520
2521        #[inline(always)]
2522        fn inline_align(_context: fidl::encoding::Context) -> usize {
2523            std::mem::align_of::<u8>()
2524        }
2525
2526        #[inline(always)]
2527        fn inline_size(_context: fidl::encoding::Context) -> usize {
2528            std::mem::size_of::<u8>()
2529        }
2530
2531        #[inline(always)]
2532        fn encode_is_copy() -> bool {
2533            true
2534        }
2535
2536        #[inline(always)]
2537        fn decode_is_copy() -> bool {
2538            false
2539        }
2540    }
2541
2542    impl fidl::encoding::ValueTypeMarker for RepeatStatusMode {
2543        type Borrowed<'a> = Self;
2544        #[inline(always)]
2545        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2546            *value
2547        }
2548    }
2549
2550    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2551        for RepeatStatusMode
2552    {
2553        #[inline]
2554        unsafe fn encode(
2555            self,
2556            encoder: &mut fidl::encoding::Encoder<'_, D>,
2557            offset: usize,
2558            _depth: fidl::encoding::Depth,
2559        ) -> fidl::Result<()> {
2560            encoder.debug_check_bounds::<Self>(offset);
2561            encoder.write_num(self.into_primitive(), offset);
2562            Ok(())
2563        }
2564    }
2565
2566    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepeatStatusMode {
2567        #[inline(always)]
2568        fn new_empty() -> Self {
2569            Self::Off
2570        }
2571
2572        #[inline]
2573        unsafe fn decode(
2574            &mut self,
2575            decoder: &mut fidl::encoding::Decoder<'_, D>,
2576            offset: usize,
2577            _depth: fidl::encoding::Depth,
2578        ) -> fidl::Result<()> {
2579            decoder.debug_check_bounds::<Self>(offset);
2580            let prim = decoder.read_num::<u8>(offset);
2581
2582            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2583            Ok(())
2584        }
2585    }
2586    unsafe impl fidl::encoding::TypeMarker for ScanMode {
2587        type Owned = Self;
2588
2589        #[inline(always)]
2590        fn inline_align(_context: fidl::encoding::Context) -> usize {
2591            std::mem::align_of::<u8>()
2592        }
2593
2594        #[inline(always)]
2595        fn inline_size(_context: fidl::encoding::Context) -> usize {
2596            std::mem::size_of::<u8>()
2597        }
2598
2599        #[inline(always)]
2600        fn encode_is_copy() -> bool {
2601            true
2602        }
2603
2604        #[inline(always)]
2605        fn decode_is_copy() -> bool {
2606            false
2607        }
2608    }
2609
2610    impl fidl::encoding::ValueTypeMarker for ScanMode {
2611        type Borrowed<'a> = Self;
2612        #[inline(always)]
2613        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2614            *value
2615        }
2616    }
2617
2618    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScanMode {
2619        #[inline]
2620        unsafe fn encode(
2621            self,
2622            encoder: &mut fidl::encoding::Encoder<'_, D>,
2623            offset: usize,
2624            _depth: fidl::encoding::Depth,
2625        ) -> fidl::Result<()> {
2626            encoder.debug_check_bounds::<Self>(offset);
2627            encoder.write_num(self.into_primitive(), offset);
2628            Ok(())
2629        }
2630    }
2631
2632    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanMode {
2633        #[inline(always)]
2634        fn new_empty() -> Self {
2635            Self::Off
2636        }
2637
2638        #[inline]
2639        unsafe fn decode(
2640            &mut self,
2641            decoder: &mut fidl::encoding::Decoder<'_, D>,
2642            offset: usize,
2643            _depth: fidl::encoding::Depth,
2644        ) -> fidl::Result<()> {
2645            decoder.debug_check_bounds::<Self>(offset);
2646            let prim = decoder.read_num::<u8>(offset);
2647
2648            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2649            Ok(())
2650        }
2651    }
2652    unsafe impl fidl::encoding::TypeMarker for ShuffleMode {
2653        type Owned = Self;
2654
2655        #[inline(always)]
2656        fn inline_align(_context: fidl::encoding::Context) -> usize {
2657            std::mem::align_of::<u8>()
2658        }
2659
2660        #[inline(always)]
2661        fn inline_size(_context: fidl::encoding::Context) -> usize {
2662            std::mem::size_of::<u8>()
2663        }
2664
2665        #[inline(always)]
2666        fn encode_is_copy() -> bool {
2667            true
2668        }
2669
2670        #[inline(always)]
2671        fn decode_is_copy() -> bool {
2672            false
2673        }
2674    }
2675
2676    impl fidl::encoding::ValueTypeMarker for ShuffleMode {
2677        type Borrowed<'a> = Self;
2678        #[inline(always)]
2679        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2680            *value
2681        }
2682    }
2683
2684    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ShuffleMode {
2685        #[inline]
2686        unsafe fn encode(
2687            self,
2688            encoder: &mut fidl::encoding::Encoder<'_, D>,
2689            offset: usize,
2690            _depth: fidl::encoding::Depth,
2691        ) -> fidl::Result<()> {
2692            encoder.debug_check_bounds::<Self>(offset);
2693            encoder.write_num(self.into_primitive(), offset);
2694            Ok(())
2695        }
2696    }
2697
2698    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ShuffleMode {
2699        #[inline(always)]
2700        fn new_empty() -> Self {
2701            Self::Off
2702        }
2703
2704        #[inline]
2705        unsafe fn decode(
2706            &mut self,
2707            decoder: &mut fidl::encoding::Decoder<'_, D>,
2708            offset: usize,
2709            _depth: fidl::encoding::Depth,
2710        ) -> fidl::Result<()> {
2711            decoder.debug_check_bounds::<Self>(offset);
2712            let prim = decoder.read_num::<u8>(offset);
2713
2714            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2715            Ok(())
2716        }
2717    }
2718    unsafe impl fidl::encoding::TypeMarker for SystemStatus {
2719        type Owned = Self;
2720
2721        #[inline(always)]
2722        fn inline_align(_context: fidl::encoding::Context) -> usize {
2723            std::mem::align_of::<u8>()
2724        }
2725
2726        #[inline(always)]
2727        fn inline_size(_context: fidl::encoding::Context) -> usize {
2728            std::mem::size_of::<u8>()
2729        }
2730
2731        #[inline(always)]
2732        fn encode_is_copy() -> bool {
2733            true
2734        }
2735
2736        #[inline(always)]
2737        fn decode_is_copy() -> bool {
2738            false
2739        }
2740    }
2741
2742    impl fidl::encoding::ValueTypeMarker for SystemStatus {
2743        type Borrowed<'a> = Self;
2744        #[inline(always)]
2745        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2746            *value
2747        }
2748    }
2749
2750    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SystemStatus {
2751        #[inline]
2752        unsafe fn encode(
2753            self,
2754            encoder: &mut fidl::encoding::Encoder<'_, D>,
2755            offset: usize,
2756            _depth: fidl::encoding::Depth,
2757        ) -> fidl::Result<()> {
2758            encoder.debug_check_bounds::<Self>(offset);
2759            encoder.write_num(self.into_primitive(), offset);
2760            Ok(())
2761        }
2762    }
2763
2764    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SystemStatus {
2765        #[inline(always)]
2766        fn new_empty() -> Self {
2767            Self::PowerOn
2768        }
2769
2770        #[inline]
2771        unsafe fn decode(
2772            &mut self,
2773            decoder: &mut fidl::encoding::Decoder<'_, D>,
2774            offset: usize,
2775            _depth: fidl::encoding::Depth,
2776        ) -> fidl::Result<()> {
2777            decoder.debug_check_bounds::<Self>(offset);
2778            let prim = decoder.read_num::<u8>(offset);
2779
2780            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2781            Ok(())
2782        }
2783    }
2784    unsafe impl fidl::encoding::TypeMarker for TargetAvcError {
2785        type Owned = Self;
2786
2787        #[inline(always)]
2788        fn inline_align(_context: fidl::encoding::Context) -> usize {
2789            std::mem::align_of::<u32>()
2790        }
2791
2792        #[inline(always)]
2793        fn inline_size(_context: fidl::encoding::Context) -> usize {
2794            std::mem::size_of::<u32>()
2795        }
2796
2797        #[inline(always)]
2798        fn encode_is_copy() -> bool {
2799            true
2800        }
2801
2802        #[inline(always)]
2803        fn decode_is_copy() -> bool {
2804            false
2805        }
2806    }
2807
2808    impl fidl::encoding::ValueTypeMarker for TargetAvcError {
2809        type Borrowed<'a> = Self;
2810        #[inline(always)]
2811        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2812            *value
2813        }
2814    }
2815
2816    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TargetAvcError {
2817        #[inline]
2818        unsafe fn encode(
2819            self,
2820            encoder: &mut fidl::encoding::Encoder<'_, D>,
2821            offset: usize,
2822            _depth: fidl::encoding::Depth,
2823        ) -> fidl::Result<()> {
2824            encoder.debug_check_bounds::<Self>(offset);
2825            encoder.write_num(self.into_primitive(), offset);
2826            Ok(())
2827        }
2828    }
2829
2830    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TargetAvcError {
2831        #[inline(always)]
2832        fn new_empty() -> Self {
2833            Self::RejectedInvalidCommand
2834        }
2835
2836        #[inline]
2837        unsafe fn decode(
2838            &mut self,
2839            decoder: &mut fidl::encoding::Decoder<'_, D>,
2840            offset: usize,
2841            _depth: fidl::encoding::Depth,
2842        ) -> fidl::Result<()> {
2843            decoder.debug_check_bounds::<Self>(offset);
2844            let prim = decoder.read_num::<u32>(offset);
2845
2846            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2847            Ok(())
2848        }
2849    }
2850    unsafe impl fidl::encoding::TypeMarker for TargetPassthroughError {
2851        type Owned = Self;
2852
2853        #[inline(always)]
2854        fn inline_align(_context: fidl::encoding::Context) -> usize {
2855            std::mem::align_of::<u32>()
2856        }
2857
2858        #[inline(always)]
2859        fn inline_size(_context: fidl::encoding::Context) -> usize {
2860            std::mem::size_of::<u32>()
2861        }
2862
2863        #[inline(always)]
2864        fn encode_is_copy() -> bool {
2865            true
2866        }
2867
2868        #[inline(always)]
2869        fn decode_is_copy() -> bool {
2870            false
2871        }
2872    }
2873
2874    impl fidl::encoding::ValueTypeMarker for TargetPassthroughError {
2875        type Borrowed<'a> = Self;
2876        #[inline(always)]
2877        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2878            *value
2879        }
2880    }
2881
2882    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2883        for TargetPassthroughError
2884    {
2885        #[inline]
2886        unsafe fn encode(
2887            self,
2888            encoder: &mut fidl::encoding::Encoder<'_, D>,
2889            offset: usize,
2890            _depth: fidl::encoding::Depth,
2891        ) -> fidl::Result<()> {
2892            encoder.debug_check_bounds::<Self>(offset);
2893            encoder.write_num(self.into_primitive(), offset);
2894            Ok(())
2895        }
2896    }
2897
2898    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2899        for TargetPassthroughError
2900    {
2901        #[inline(always)]
2902        fn new_empty() -> Self {
2903            Self::CommandNotImplemented
2904        }
2905
2906        #[inline]
2907        unsafe fn decode(
2908            &mut self,
2909            decoder: &mut fidl::encoding::Decoder<'_, D>,
2910            offset: usize,
2911            _depth: fidl::encoding::Depth,
2912        ) -> fidl::Result<()> {
2913            decoder.debug_check_bounds::<Self>(offset);
2914            let prim = decoder.read_num::<u32>(offset);
2915
2916            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2917            Ok(())
2918        }
2919    }
2920
2921    impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerGetCurrentVolumeResponse {
2922        type Borrowed<'a> = &'a Self;
2923        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2924            value
2925        }
2926    }
2927
2928    unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerGetCurrentVolumeResponse {
2929        type Owned = Self;
2930
2931        #[inline(always)]
2932        fn inline_align(_context: fidl::encoding::Context) -> usize {
2933            1
2934        }
2935
2936        #[inline(always)]
2937        fn inline_size(_context: fidl::encoding::Context) -> usize {
2938            1
2939        }
2940        #[inline(always)]
2941        fn encode_is_copy() -> bool {
2942            true
2943        }
2944
2945        #[inline(always)]
2946        fn decode_is_copy() -> bool {
2947            true
2948        }
2949    }
2950
2951    unsafe impl<D: fidl::encoding::ResourceDialect>
2952        fidl::encoding::Encode<AbsoluteVolumeHandlerGetCurrentVolumeResponse, D>
2953        for &AbsoluteVolumeHandlerGetCurrentVolumeResponse
2954    {
2955        #[inline]
2956        unsafe fn encode(
2957            self,
2958            encoder: &mut fidl::encoding::Encoder<'_, D>,
2959            offset: usize,
2960            _depth: fidl::encoding::Depth,
2961        ) -> fidl::Result<()> {
2962            encoder.debug_check_bounds::<AbsoluteVolumeHandlerGetCurrentVolumeResponse>(offset);
2963            unsafe {
2964                // Copy the object into the buffer.
2965                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2966                (buf_ptr as *mut AbsoluteVolumeHandlerGetCurrentVolumeResponse).write_unaligned(
2967                    (self as *const AbsoluteVolumeHandlerGetCurrentVolumeResponse).read(),
2968                );
2969                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2970                // done second because the memcpy will write garbage to these bytes.
2971            }
2972            Ok(())
2973        }
2974    }
2975    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
2976        fidl::encoding::Encode<AbsoluteVolumeHandlerGetCurrentVolumeResponse, D> for (T0,)
2977    {
2978        #[inline]
2979        unsafe fn encode(
2980            self,
2981            encoder: &mut fidl::encoding::Encoder<'_, D>,
2982            offset: usize,
2983            depth: fidl::encoding::Depth,
2984        ) -> fidl::Result<()> {
2985            encoder.debug_check_bounds::<AbsoluteVolumeHandlerGetCurrentVolumeResponse>(offset);
2986            // Zero out padding regions. There's no need to apply masks
2987            // because the unmasked parts will be overwritten by fields.
2988            // Write the fields.
2989            self.0.encode(encoder, offset + 0, depth)?;
2990            Ok(())
2991        }
2992    }
2993
2994    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2995        for AbsoluteVolumeHandlerGetCurrentVolumeResponse
2996    {
2997        #[inline(always)]
2998        fn new_empty() -> Self {
2999            Self { volume: fidl::new_empty!(u8, D) }
3000        }
3001
3002        #[inline]
3003        unsafe fn decode(
3004            &mut self,
3005            decoder: &mut fidl::encoding::Decoder<'_, D>,
3006            offset: usize,
3007            _depth: fidl::encoding::Depth,
3008        ) -> fidl::Result<()> {
3009            decoder.debug_check_bounds::<Self>(offset);
3010            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3011            // Verify that padding bytes are zero.
3012            // Copy from the buffer into the object.
3013            unsafe {
3014                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3015            }
3016            Ok(())
3017        }
3018    }
3019
3020    impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerOnVolumeChangedResponse {
3021        type Borrowed<'a> = &'a Self;
3022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3023            value
3024        }
3025    }
3026
3027    unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerOnVolumeChangedResponse {
3028        type Owned = Self;
3029
3030        #[inline(always)]
3031        fn inline_align(_context: fidl::encoding::Context) -> usize {
3032            1
3033        }
3034
3035        #[inline(always)]
3036        fn inline_size(_context: fidl::encoding::Context) -> usize {
3037            1
3038        }
3039        #[inline(always)]
3040        fn encode_is_copy() -> bool {
3041            true
3042        }
3043
3044        #[inline(always)]
3045        fn decode_is_copy() -> bool {
3046            true
3047        }
3048    }
3049
3050    unsafe impl<D: fidl::encoding::ResourceDialect>
3051        fidl::encoding::Encode<AbsoluteVolumeHandlerOnVolumeChangedResponse, D>
3052        for &AbsoluteVolumeHandlerOnVolumeChangedResponse
3053    {
3054        #[inline]
3055        unsafe fn encode(
3056            self,
3057            encoder: &mut fidl::encoding::Encoder<'_, D>,
3058            offset: usize,
3059            _depth: fidl::encoding::Depth,
3060        ) -> fidl::Result<()> {
3061            encoder.debug_check_bounds::<AbsoluteVolumeHandlerOnVolumeChangedResponse>(offset);
3062            unsafe {
3063                // Copy the object into the buffer.
3064                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3065                (buf_ptr as *mut AbsoluteVolumeHandlerOnVolumeChangedResponse).write_unaligned(
3066                    (self as *const AbsoluteVolumeHandlerOnVolumeChangedResponse).read(),
3067                );
3068                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3069                // done second because the memcpy will write garbage to these bytes.
3070            }
3071            Ok(())
3072        }
3073    }
3074    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3075        fidl::encoding::Encode<AbsoluteVolumeHandlerOnVolumeChangedResponse, D> for (T0,)
3076    {
3077        #[inline]
3078        unsafe fn encode(
3079            self,
3080            encoder: &mut fidl::encoding::Encoder<'_, D>,
3081            offset: usize,
3082            depth: fidl::encoding::Depth,
3083        ) -> fidl::Result<()> {
3084            encoder.debug_check_bounds::<AbsoluteVolumeHandlerOnVolumeChangedResponse>(offset);
3085            // Zero out padding regions. There's no need to apply masks
3086            // because the unmasked parts will be overwritten by fields.
3087            // Write the fields.
3088            self.0.encode(encoder, offset + 0, depth)?;
3089            Ok(())
3090        }
3091    }
3092
3093    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3094        for AbsoluteVolumeHandlerOnVolumeChangedResponse
3095    {
3096        #[inline(always)]
3097        fn new_empty() -> Self {
3098            Self { new_volume: fidl::new_empty!(u8, D) }
3099        }
3100
3101        #[inline]
3102        unsafe fn decode(
3103            &mut self,
3104            decoder: &mut fidl::encoding::Decoder<'_, D>,
3105            offset: usize,
3106            _depth: fidl::encoding::Depth,
3107        ) -> fidl::Result<()> {
3108            decoder.debug_check_bounds::<Self>(offset);
3109            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3110            // Verify that padding bytes are zero.
3111            // Copy from the buffer into the object.
3112            unsafe {
3113                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3114            }
3115            Ok(())
3116        }
3117    }
3118
3119    impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerSetVolumeRequest {
3120        type Borrowed<'a> = &'a Self;
3121        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3122            value
3123        }
3124    }
3125
3126    unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerSetVolumeRequest {
3127        type Owned = Self;
3128
3129        #[inline(always)]
3130        fn inline_align(_context: fidl::encoding::Context) -> usize {
3131            1
3132        }
3133
3134        #[inline(always)]
3135        fn inline_size(_context: fidl::encoding::Context) -> usize {
3136            1
3137        }
3138        #[inline(always)]
3139        fn encode_is_copy() -> bool {
3140            true
3141        }
3142
3143        #[inline(always)]
3144        fn decode_is_copy() -> bool {
3145            true
3146        }
3147    }
3148
3149    unsafe impl<D: fidl::encoding::ResourceDialect>
3150        fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeRequest, D>
3151        for &AbsoluteVolumeHandlerSetVolumeRequest
3152    {
3153        #[inline]
3154        unsafe fn encode(
3155            self,
3156            encoder: &mut fidl::encoding::Encoder<'_, D>,
3157            offset: usize,
3158            _depth: fidl::encoding::Depth,
3159        ) -> fidl::Result<()> {
3160            encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeRequest>(offset);
3161            unsafe {
3162                // Copy the object into the buffer.
3163                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3164                (buf_ptr as *mut AbsoluteVolumeHandlerSetVolumeRequest)
3165                    .write_unaligned((self as *const AbsoluteVolumeHandlerSetVolumeRequest).read());
3166                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3167                // done second because the memcpy will write garbage to these bytes.
3168            }
3169            Ok(())
3170        }
3171    }
3172    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3173        fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeRequest, D> for (T0,)
3174    {
3175        #[inline]
3176        unsafe fn encode(
3177            self,
3178            encoder: &mut fidl::encoding::Encoder<'_, D>,
3179            offset: usize,
3180            depth: fidl::encoding::Depth,
3181        ) -> fidl::Result<()> {
3182            encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeRequest>(offset);
3183            // Zero out padding regions. There's no need to apply masks
3184            // because the unmasked parts will be overwritten by fields.
3185            // Write the fields.
3186            self.0.encode(encoder, offset + 0, depth)?;
3187            Ok(())
3188        }
3189    }
3190
3191    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3192        for AbsoluteVolumeHandlerSetVolumeRequest
3193    {
3194        #[inline(always)]
3195        fn new_empty() -> Self {
3196            Self { requested_volume: fidl::new_empty!(u8, D) }
3197        }
3198
3199        #[inline]
3200        unsafe fn decode(
3201            &mut self,
3202            decoder: &mut fidl::encoding::Decoder<'_, D>,
3203            offset: usize,
3204            _depth: fidl::encoding::Depth,
3205        ) -> fidl::Result<()> {
3206            decoder.debug_check_bounds::<Self>(offset);
3207            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3208            // Verify that padding bytes are zero.
3209            // Copy from the buffer into the object.
3210            unsafe {
3211                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3212            }
3213            Ok(())
3214        }
3215    }
3216
3217    impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerSetVolumeResponse {
3218        type Borrowed<'a> = &'a Self;
3219        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3220            value
3221        }
3222    }
3223
3224    unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerSetVolumeResponse {
3225        type Owned = Self;
3226
3227        #[inline(always)]
3228        fn inline_align(_context: fidl::encoding::Context) -> usize {
3229            1
3230        }
3231
3232        #[inline(always)]
3233        fn inline_size(_context: fidl::encoding::Context) -> usize {
3234            1
3235        }
3236        #[inline(always)]
3237        fn encode_is_copy() -> bool {
3238            true
3239        }
3240
3241        #[inline(always)]
3242        fn decode_is_copy() -> bool {
3243            true
3244        }
3245    }
3246
3247    unsafe impl<D: fidl::encoding::ResourceDialect>
3248        fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeResponse, D>
3249        for &AbsoluteVolumeHandlerSetVolumeResponse
3250    {
3251        #[inline]
3252        unsafe fn encode(
3253            self,
3254            encoder: &mut fidl::encoding::Encoder<'_, D>,
3255            offset: usize,
3256            _depth: fidl::encoding::Depth,
3257        ) -> fidl::Result<()> {
3258            encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeResponse>(offset);
3259            unsafe {
3260                // Copy the object into the buffer.
3261                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3262                (buf_ptr as *mut AbsoluteVolumeHandlerSetVolumeResponse).write_unaligned(
3263                    (self as *const AbsoluteVolumeHandlerSetVolumeResponse).read(),
3264                );
3265                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3266                // done second because the memcpy will write garbage to these bytes.
3267            }
3268            Ok(())
3269        }
3270    }
3271    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3272        fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeResponse, D> for (T0,)
3273    {
3274        #[inline]
3275        unsafe fn encode(
3276            self,
3277            encoder: &mut fidl::encoding::Encoder<'_, D>,
3278            offset: usize,
3279            depth: fidl::encoding::Depth,
3280        ) -> fidl::Result<()> {
3281            encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeResponse>(offset);
3282            // Zero out padding regions. There's no need to apply masks
3283            // because the unmasked parts will be overwritten by fields.
3284            // Write the fields.
3285            self.0.encode(encoder, offset + 0, depth)?;
3286            Ok(())
3287        }
3288    }
3289
3290    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3291        for AbsoluteVolumeHandlerSetVolumeResponse
3292    {
3293        #[inline(always)]
3294        fn new_empty() -> Self {
3295            Self { set_volume: fidl::new_empty!(u8, D) }
3296        }
3297
3298        #[inline]
3299        unsafe fn decode(
3300            &mut self,
3301            decoder: &mut fidl::encoding::Decoder<'_, D>,
3302            offset: usize,
3303            _depth: fidl::encoding::Depth,
3304        ) -> fidl::Result<()> {
3305            decoder.debug_check_bounds::<Self>(offset);
3306            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3307            // Verify that padding bytes are zero.
3308            // Copy from the buffer into the object.
3309            unsafe {
3310                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3311            }
3312            Ok(())
3313        }
3314    }
3315
3316    impl fidl::encoding::ValueTypeMarker for AddressedPlayerId {
3317        type Borrowed<'a> = &'a Self;
3318        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3319            value
3320        }
3321    }
3322
3323    unsafe impl fidl::encoding::TypeMarker for AddressedPlayerId {
3324        type Owned = Self;
3325
3326        #[inline(always)]
3327        fn inline_align(_context: fidl::encoding::Context) -> usize {
3328            2
3329        }
3330
3331        #[inline(always)]
3332        fn inline_size(_context: fidl::encoding::Context) -> usize {
3333            2
3334        }
3335        #[inline(always)]
3336        fn encode_is_copy() -> bool {
3337            true
3338        }
3339
3340        #[inline(always)]
3341        fn decode_is_copy() -> bool {
3342            true
3343        }
3344    }
3345
3346    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressedPlayerId, D>
3347        for &AddressedPlayerId
3348    {
3349        #[inline]
3350        unsafe fn encode(
3351            self,
3352            encoder: &mut fidl::encoding::Encoder<'_, D>,
3353            offset: usize,
3354            _depth: fidl::encoding::Depth,
3355        ) -> fidl::Result<()> {
3356            encoder.debug_check_bounds::<AddressedPlayerId>(offset);
3357            unsafe {
3358                // Copy the object into the buffer.
3359                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3360                (buf_ptr as *mut AddressedPlayerId)
3361                    .write_unaligned((self as *const AddressedPlayerId).read());
3362                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3363                // done second because the memcpy will write garbage to these bytes.
3364            }
3365            Ok(())
3366        }
3367    }
3368    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3369        fidl::encoding::Encode<AddressedPlayerId, D> for (T0,)
3370    {
3371        #[inline]
3372        unsafe fn encode(
3373            self,
3374            encoder: &mut fidl::encoding::Encoder<'_, D>,
3375            offset: usize,
3376            depth: fidl::encoding::Depth,
3377        ) -> fidl::Result<()> {
3378            encoder.debug_check_bounds::<AddressedPlayerId>(offset);
3379            // Zero out padding regions. There's no need to apply masks
3380            // because the unmasked parts will be overwritten by fields.
3381            // Write the fields.
3382            self.0.encode(encoder, offset + 0, depth)?;
3383            Ok(())
3384        }
3385    }
3386
3387    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressedPlayerId {
3388        #[inline(always)]
3389        fn new_empty() -> Self {
3390            Self { id: fidl::new_empty!(u16, D) }
3391        }
3392
3393        #[inline]
3394        unsafe fn decode(
3395            &mut self,
3396            decoder: &mut fidl::encoding::Decoder<'_, D>,
3397            offset: usize,
3398            _depth: fidl::encoding::Depth,
3399        ) -> fidl::Result<()> {
3400            decoder.debug_check_bounds::<Self>(offset);
3401            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3402            // Verify that padding bytes are zero.
3403            // Copy from the buffer into the object.
3404            unsafe {
3405                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3406            }
3407            Ok(())
3408        }
3409    }
3410
3411    impl fidl::encoding::ValueTypeMarker for BrowseControllerChangePathRequest {
3412        type Borrowed<'a> = &'a Self;
3413        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3414            value
3415        }
3416    }
3417
3418    unsafe impl fidl::encoding::TypeMarker for BrowseControllerChangePathRequest {
3419        type Owned = Self;
3420
3421        #[inline(always)]
3422        fn inline_align(_context: fidl::encoding::Context) -> usize {
3423            8
3424        }
3425
3426        #[inline(always)]
3427        fn inline_size(_context: fidl::encoding::Context) -> usize {
3428            16
3429        }
3430    }
3431
3432    unsafe impl<D: fidl::encoding::ResourceDialect>
3433        fidl::encoding::Encode<BrowseControllerChangePathRequest, D>
3434        for &BrowseControllerChangePathRequest
3435    {
3436        #[inline]
3437        unsafe fn encode(
3438            self,
3439            encoder: &mut fidl::encoding::Encoder<'_, D>,
3440            offset: usize,
3441            _depth: fidl::encoding::Depth,
3442        ) -> fidl::Result<()> {
3443            encoder.debug_check_bounds::<BrowseControllerChangePathRequest>(offset);
3444            // Delegate to tuple encoding.
3445            fidl::encoding::Encode::<BrowseControllerChangePathRequest, D>::encode(
3446                (<Path as fidl::encoding::ValueTypeMarker>::borrow(&self.path),),
3447                encoder,
3448                offset,
3449                _depth,
3450            )
3451        }
3452    }
3453    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Path, D>>
3454        fidl::encoding::Encode<BrowseControllerChangePathRequest, D> for (T0,)
3455    {
3456        #[inline]
3457        unsafe fn encode(
3458            self,
3459            encoder: &mut fidl::encoding::Encoder<'_, D>,
3460            offset: usize,
3461            depth: fidl::encoding::Depth,
3462        ) -> fidl::Result<()> {
3463            encoder.debug_check_bounds::<BrowseControllerChangePathRequest>(offset);
3464            // Zero out padding regions. There's no need to apply masks
3465            // because the unmasked parts will be overwritten by fields.
3466            // Write the fields.
3467            self.0.encode(encoder, offset + 0, depth)?;
3468            Ok(())
3469        }
3470    }
3471
3472    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3473        for BrowseControllerChangePathRequest
3474    {
3475        #[inline(always)]
3476        fn new_empty() -> Self {
3477            Self { path: fidl::new_empty!(Path, D) }
3478        }
3479
3480        #[inline]
3481        unsafe fn decode(
3482            &mut self,
3483            decoder: &mut fidl::encoding::Decoder<'_, D>,
3484            offset: usize,
3485            _depth: fidl::encoding::Depth,
3486        ) -> fidl::Result<()> {
3487            decoder.debug_check_bounds::<Self>(offset);
3488            // Verify that padding bytes are zero.
3489            fidl::decode!(Path, D, &mut self.path, decoder, offset + 0, _depth)?;
3490            Ok(())
3491        }
3492    }
3493
3494    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetFileSystemItemsRequest {
3495        type Borrowed<'a> = &'a Self;
3496        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3497            value
3498        }
3499    }
3500
3501    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetFileSystemItemsRequest {
3502        type Owned = Self;
3503
3504        #[inline(always)]
3505        fn inline_align(_context: fidl::encoding::Context) -> usize {
3506            8
3507        }
3508
3509        #[inline(always)]
3510        fn inline_size(_context: fidl::encoding::Context) -> usize {
3511            24
3512        }
3513    }
3514
3515    unsafe impl<D: fidl::encoding::ResourceDialect>
3516        fidl::encoding::Encode<BrowseControllerGetFileSystemItemsRequest, D>
3517        for &BrowseControllerGetFileSystemItemsRequest
3518    {
3519        #[inline]
3520        unsafe fn encode(
3521            self,
3522            encoder: &mut fidl::encoding::Encoder<'_, D>,
3523            offset: usize,
3524            _depth: fidl::encoding::Depth,
3525        ) -> fidl::Result<()> {
3526            encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsRequest>(offset);
3527            // Delegate to tuple encoding.
3528            fidl::encoding::Encode::<BrowseControllerGetFileSystemItemsRequest, D>::encode(
3529                (
3530                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.start_index),
3531                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.end_index),
3532                    <AttributeRequestOption as fidl::encoding::ValueTypeMarker>::borrow(
3533                        &self.attribute_option,
3534                    ),
3535                ),
3536                encoder,
3537                offset,
3538                _depth,
3539            )
3540        }
3541    }
3542    unsafe impl<
3543            D: fidl::encoding::ResourceDialect,
3544            T0: fidl::encoding::Encode<u32, D>,
3545            T1: fidl::encoding::Encode<u32, D>,
3546            T2: fidl::encoding::Encode<AttributeRequestOption, D>,
3547        > fidl::encoding::Encode<BrowseControllerGetFileSystemItemsRequest, D> for (T0, T1, T2)
3548    {
3549        #[inline]
3550        unsafe fn encode(
3551            self,
3552            encoder: &mut fidl::encoding::Encoder<'_, D>,
3553            offset: usize,
3554            depth: fidl::encoding::Depth,
3555        ) -> fidl::Result<()> {
3556            encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsRequest>(offset);
3557            // Zero out padding regions. There's no need to apply masks
3558            // because the unmasked parts will be overwritten by fields.
3559            // Write the fields.
3560            self.0.encode(encoder, offset + 0, depth)?;
3561            self.1.encode(encoder, offset + 4, depth)?;
3562            self.2.encode(encoder, offset + 8, depth)?;
3563            Ok(())
3564        }
3565    }
3566
3567    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3568        for BrowseControllerGetFileSystemItemsRequest
3569    {
3570        #[inline(always)]
3571        fn new_empty() -> Self {
3572            Self {
3573                start_index: fidl::new_empty!(u32, D),
3574                end_index: fidl::new_empty!(u32, D),
3575                attribute_option: fidl::new_empty!(AttributeRequestOption, D),
3576            }
3577        }
3578
3579        #[inline]
3580        unsafe fn decode(
3581            &mut self,
3582            decoder: &mut fidl::encoding::Decoder<'_, D>,
3583            offset: usize,
3584            _depth: fidl::encoding::Depth,
3585        ) -> fidl::Result<()> {
3586            decoder.debug_check_bounds::<Self>(offset);
3587            // Verify that padding bytes are zero.
3588            fidl::decode!(u32, D, &mut self.start_index, decoder, offset + 0, _depth)?;
3589            fidl::decode!(u32, D, &mut self.end_index, decoder, offset + 4, _depth)?;
3590            fidl::decode!(
3591                AttributeRequestOption,
3592                D,
3593                &mut self.attribute_option,
3594                decoder,
3595                offset + 8,
3596                _depth
3597            )?;
3598            Ok(())
3599        }
3600    }
3601
3602    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetMediaPlayerItemsRequest {
3603        type Borrowed<'a> = &'a Self;
3604        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3605            value
3606        }
3607    }
3608
3609    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetMediaPlayerItemsRequest {
3610        type Owned = Self;
3611
3612        #[inline(always)]
3613        fn inline_align(_context: fidl::encoding::Context) -> usize {
3614            4
3615        }
3616
3617        #[inline(always)]
3618        fn inline_size(_context: fidl::encoding::Context) -> usize {
3619            8
3620        }
3621        #[inline(always)]
3622        fn encode_is_copy() -> bool {
3623            true
3624        }
3625
3626        #[inline(always)]
3627        fn decode_is_copy() -> bool {
3628            true
3629        }
3630    }
3631
3632    unsafe impl<D: fidl::encoding::ResourceDialect>
3633        fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsRequest, D>
3634        for &BrowseControllerGetMediaPlayerItemsRequest
3635    {
3636        #[inline]
3637        unsafe fn encode(
3638            self,
3639            encoder: &mut fidl::encoding::Encoder<'_, D>,
3640            offset: usize,
3641            _depth: fidl::encoding::Depth,
3642        ) -> fidl::Result<()> {
3643            encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsRequest>(offset);
3644            unsafe {
3645                // Copy the object into the buffer.
3646                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3647                (buf_ptr as *mut BrowseControllerGetMediaPlayerItemsRequest).write_unaligned(
3648                    (self as *const BrowseControllerGetMediaPlayerItemsRequest).read(),
3649                );
3650                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3651                // done second because the memcpy will write garbage to these bytes.
3652            }
3653            Ok(())
3654        }
3655    }
3656    unsafe impl<
3657            D: fidl::encoding::ResourceDialect,
3658            T0: fidl::encoding::Encode<u32, D>,
3659            T1: fidl::encoding::Encode<u32, D>,
3660        > fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsRequest, D> for (T0, T1)
3661    {
3662        #[inline]
3663        unsafe fn encode(
3664            self,
3665            encoder: &mut fidl::encoding::Encoder<'_, D>,
3666            offset: usize,
3667            depth: fidl::encoding::Depth,
3668        ) -> fidl::Result<()> {
3669            encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsRequest>(offset);
3670            // Zero out padding regions. There's no need to apply masks
3671            // because the unmasked parts will be overwritten by fields.
3672            // Write the fields.
3673            self.0.encode(encoder, offset + 0, depth)?;
3674            self.1.encode(encoder, offset + 4, depth)?;
3675            Ok(())
3676        }
3677    }
3678
3679    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3680        for BrowseControllerGetMediaPlayerItemsRequest
3681    {
3682        #[inline(always)]
3683        fn new_empty() -> Self {
3684            Self { start_index: fidl::new_empty!(u32, D), end_index: fidl::new_empty!(u32, D) }
3685        }
3686
3687        #[inline]
3688        unsafe fn decode(
3689            &mut self,
3690            decoder: &mut fidl::encoding::Decoder<'_, D>,
3691            offset: usize,
3692            _depth: fidl::encoding::Depth,
3693        ) -> fidl::Result<()> {
3694            decoder.debug_check_bounds::<Self>(offset);
3695            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3696            // Verify that padding bytes are zero.
3697            // Copy from the buffer into the object.
3698            unsafe {
3699                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3700            }
3701            Ok(())
3702        }
3703    }
3704
3705    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetNowPlayingItemsRequest {
3706        type Borrowed<'a> = &'a Self;
3707        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3708            value
3709        }
3710    }
3711
3712    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetNowPlayingItemsRequest {
3713        type Owned = Self;
3714
3715        #[inline(always)]
3716        fn inline_align(_context: fidl::encoding::Context) -> usize {
3717            8
3718        }
3719
3720        #[inline(always)]
3721        fn inline_size(_context: fidl::encoding::Context) -> usize {
3722            24
3723        }
3724    }
3725
3726    unsafe impl<D: fidl::encoding::ResourceDialect>
3727        fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsRequest, D>
3728        for &BrowseControllerGetNowPlayingItemsRequest
3729    {
3730        #[inline]
3731        unsafe fn encode(
3732            self,
3733            encoder: &mut fidl::encoding::Encoder<'_, D>,
3734            offset: usize,
3735            _depth: fidl::encoding::Depth,
3736        ) -> fidl::Result<()> {
3737            encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsRequest>(offset);
3738            // Delegate to tuple encoding.
3739            fidl::encoding::Encode::<BrowseControllerGetNowPlayingItemsRequest, D>::encode(
3740                (
3741                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.start_index),
3742                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.end_index),
3743                    <AttributeRequestOption as fidl::encoding::ValueTypeMarker>::borrow(
3744                        &self.attribute_option,
3745                    ),
3746                ),
3747                encoder,
3748                offset,
3749                _depth,
3750            )
3751        }
3752    }
3753    unsafe impl<
3754            D: fidl::encoding::ResourceDialect,
3755            T0: fidl::encoding::Encode<u32, D>,
3756            T1: fidl::encoding::Encode<u32, D>,
3757            T2: fidl::encoding::Encode<AttributeRequestOption, D>,
3758        > fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsRequest, D> for (T0, T1, T2)
3759    {
3760        #[inline]
3761        unsafe fn encode(
3762            self,
3763            encoder: &mut fidl::encoding::Encoder<'_, D>,
3764            offset: usize,
3765            depth: fidl::encoding::Depth,
3766        ) -> fidl::Result<()> {
3767            encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsRequest>(offset);
3768            // Zero out padding regions. There's no need to apply masks
3769            // because the unmasked parts will be overwritten by fields.
3770            // Write the fields.
3771            self.0.encode(encoder, offset + 0, depth)?;
3772            self.1.encode(encoder, offset + 4, depth)?;
3773            self.2.encode(encoder, offset + 8, depth)?;
3774            Ok(())
3775        }
3776    }
3777
3778    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3779        for BrowseControllerGetNowPlayingItemsRequest
3780    {
3781        #[inline(always)]
3782        fn new_empty() -> Self {
3783            Self {
3784                start_index: fidl::new_empty!(u32, D),
3785                end_index: fidl::new_empty!(u32, D),
3786                attribute_option: fidl::new_empty!(AttributeRequestOption, D),
3787            }
3788        }
3789
3790        #[inline]
3791        unsafe fn decode(
3792            &mut self,
3793            decoder: &mut fidl::encoding::Decoder<'_, D>,
3794            offset: usize,
3795            _depth: fidl::encoding::Depth,
3796        ) -> fidl::Result<()> {
3797            decoder.debug_check_bounds::<Self>(offset);
3798            // Verify that padding bytes are zero.
3799            fidl::decode!(u32, D, &mut self.start_index, decoder, offset + 0, _depth)?;
3800            fidl::decode!(u32, D, &mut self.end_index, decoder, offset + 4, _depth)?;
3801            fidl::decode!(
3802                AttributeRequestOption,
3803                D,
3804                &mut self.attribute_option,
3805                decoder,
3806                offset + 8,
3807                _depth
3808            )?;
3809            Ok(())
3810        }
3811    }
3812
3813    impl fidl::encoding::ValueTypeMarker for BrowseControllerPlayFileSystemItemRequest {
3814        type Borrowed<'a> = &'a Self;
3815        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3816            value
3817        }
3818    }
3819
3820    unsafe impl fidl::encoding::TypeMarker for BrowseControllerPlayFileSystemItemRequest {
3821        type Owned = Self;
3822
3823        #[inline(always)]
3824        fn inline_align(_context: fidl::encoding::Context) -> usize {
3825            8
3826        }
3827
3828        #[inline(always)]
3829        fn inline_size(_context: fidl::encoding::Context) -> usize {
3830            8
3831        }
3832        #[inline(always)]
3833        fn encode_is_copy() -> bool {
3834            true
3835        }
3836
3837        #[inline(always)]
3838        fn decode_is_copy() -> bool {
3839            true
3840        }
3841    }
3842
3843    unsafe impl<D: fidl::encoding::ResourceDialect>
3844        fidl::encoding::Encode<BrowseControllerPlayFileSystemItemRequest, D>
3845        for &BrowseControllerPlayFileSystemItemRequest
3846    {
3847        #[inline]
3848        unsafe fn encode(
3849            self,
3850            encoder: &mut fidl::encoding::Encoder<'_, D>,
3851            offset: usize,
3852            _depth: fidl::encoding::Depth,
3853        ) -> fidl::Result<()> {
3854            encoder.debug_check_bounds::<BrowseControllerPlayFileSystemItemRequest>(offset);
3855            unsafe {
3856                // Copy the object into the buffer.
3857                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3858                (buf_ptr as *mut BrowseControllerPlayFileSystemItemRequest).write_unaligned(
3859                    (self as *const BrowseControllerPlayFileSystemItemRequest).read(),
3860                );
3861                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3862                // done second because the memcpy will write garbage to these bytes.
3863            }
3864            Ok(())
3865        }
3866    }
3867    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
3868        fidl::encoding::Encode<BrowseControllerPlayFileSystemItemRequest, D> for (T0,)
3869    {
3870        #[inline]
3871        unsafe fn encode(
3872            self,
3873            encoder: &mut fidl::encoding::Encoder<'_, D>,
3874            offset: usize,
3875            depth: fidl::encoding::Depth,
3876        ) -> fidl::Result<()> {
3877            encoder.debug_check_bounds::<BrowseControllerPlayFileSystemItemRequest>(offset);
3878            // Zero out padding regions. There's no need to apply masks
3879            // because the unmasked parts will be overwritten by fields.
3880            // Write the fields.
3881            self.0.encode(encoder, offset + 0, depth)?;
3882            Ok(())
3883        }
3884    }
3885
3886    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3887        for BrowseControllerPlayFileSystemItemRequest
3888    {
3889        #[inline(always)]
3890        fn new_empty() -> Self {
3891            Self { uid: fidl::new_empty!(u64, D) }
3892        }
3893
3894        #[inline]
3895        unsafe fn decode(
3896            &mut self,
3897            decoder: &mut fidl::encoding::Decoder<'_, D>,
3898            offset: usize,
3899            _depth: fidl::encoding::Depth,
3900        ) -> fidl::Result<()> {
3901            decoder.debug_check_bounds::<Self>(offset);
3902            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3903            // Verify that padding bytes are zero.
3904            // Copy from the buffer into the object.
3905            unsafe {
3906                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3907            }
3908            Ok(())
3909        }
3910    }
3911
3912    impl fidl::encoding::ValueTypeMarker for BrowseControllerPlayNowPlayingItemRequest {
3913        type Borrowed<'a> = &'a Self;
3914        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3915            value
3916        }
3917    }
3918
3919    unsafe impl fidl::encoding::TypeMarker for BrowseControllerPlayNowPlayingItemRequest {
3920        type Owned = Self;
3921
3922        #[inline(always)]
3923        fn inline_align(_context: fidl::encoding::Context) -> usize {
3924            8
3925        }
3926
3927        #[inline(always)]
3928        fn inline_size(_context: fidl::encoding::Context) -> usize {
3929            8
3930        }
3931        #[inline(always)]
3932        fn encode_is_copy() -> bool {
3933            true
3934        }
3935
3936        #[inline(always)]
3937        fn decode_is_copy() -> bool {
3938            true
3939        }
3940    }
3941
3942    unsafe impl<D: fidl::encoding::ResourceDialect>
3943        fidl::encoding::Encode<BrowseControllerPlayNowPlayingItemRequest, D>
3944        for &BrowseControllerPlayNowPlayingItemRequest
3945    {
3946        #[inline]
3947        unsafe fn encode(
3948            self,
3949            encoder: &mut fidl::encoding::Encoder<'_, D>,
3950            offset: usize,
3951            _depth: fidl::encoding::Depth,
3952        ) -> fidl::Result<()> {
3953            encoder.debug_check_bounds::<BrowseControllerPlayNowPlayingItemRequest>(offset);
3954            unsafe {
3955                // Copy the object into the buffer.
3956                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3957                (buf_ptr as *mut BrowseControllerPlayNowPlayingItemRequest).write_unaligned(
3958                    (self as *const BrowseControllerPlayNowPlayingItemRequest).read(),
3959                );
3960                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
3961                // done second because the memcpy will write garbage to these bytes.
3962            }
3963            Ok(())
3964        }
3965    }
3966    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
3967        fidl::encoding::Encode<BrowseControllerPlayNowPlayingItemRequest, D> for (T0,)
3968    {
3969        #[inline]
3970        unsafe fn encode(
3971            self,
3972            encoder: &mut fidl::encoding::Encoder<'_, D>,
3973            offset: usize,
3974            depth: fidl::encoding::Depth,
3975        ) -> fidl::Result<()> {
3976            encoder.debug_check_bounds::<BrowseControllerPlayNowPlayingItemRequest>(offset);
3977            // Zero out padding regions. There's no need to apply masks
3978            // because the unmasked parts will be overwritten by fields.
3979            // Write the fields.
3980            self.0.encode(encoder, offset + 0, depth)?;
3981            Ok(())
3982        }
3983    }
3984
3985    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3986        for BrowseControllerPlayNowPlayingItemRequest
3987    {
3988        #[inline(always)]
3989        fn new_empty() -> Self {
3990            Self { uid: fidl::new_empty!(u64, D) }
3991        }
3992
3993        #[inline]
3994        unsafe fn decode(
3995            &mut self,
3996            decoder: &mut fidl::encoding::Decoder<'_, D>,
3997            offset: usize,
3998            _depth: fidl::encoding::Depth,
3999        ) -> fidl::Result<()> {
4000            decoder.debug_check_bounds::<Self>(offset);
4001            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4002            // Verify that padding bytes are zero.
4003            // Copy from the buffer into the object.
4004            unsafe {
4005                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
4006            }
4007            Ok(())
4008        }
4009    }
4010
4011    impl fidl::encoding::ValueTypeMarker for BrowseControllerSetBrowsedPlayerRequest {
4012        type Borrowed<'a> = &'a Self;
4013        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4014            value
4015        }
4016    }
4017
4018    unsafe impl fidl::encoding::TypeMarker for BrowseControllerSetBrowsedPlayerRequest {
4019        type Owned = Self;
4020
4021        #[inline(always)]
4022        fn inline_align(_context: fidl::encoding::Context) -> usize {
4023            2
4024        }
4025
4026        #[inline(always)]
4027        fn inline_size(_context: fidl::encoding::Context) -> usize {
4028            2
4029        }
4030        #[inline(always)]
4031        fn encode_is_copy() -> bool {
4032            true
4033        }
4034
4035        #[inline(always)]
4036        fn decode_is_copy() -> bool {
4037            true
4038        }
4039    }
4040
4041    unsafe impl<D: fidl::encoding::ResourceDialect>
4042        fidl::encoding::Encode<BrowseControllerSetBrowsedPlayerRequest, D>
4043        for &BrowseControllerSetBrowsedPlayerRequest
4044    {
4045        #[inline]
4046        unsafe fn encode(
4047            self,
4048            encoder: &mut fidl::encoding::Encoder<'_, D>,
4049            offset: usize,
4050            _depth: fidl::encoding::Depth,
4051        ) -> fidl::Result<()> {
4052            encoder.debug_check_bounds::<BrowseControllerSetBrowsedPlayerRequest>(offset);
4053            unsafe {
4054                // Copy the object into the buffer.
4055                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4056                (buf_ptr as *mut BrowseControllerSetBrowsedPlayerRequest).write_unaligned(
4057                    (self as *const BrowseControllerSetBrowsedPlayerRequest).read(),
4058                );
4059                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
4060                // done second because the memcpy will write garbage to these bytes.
4061            }
4062            Ok(())
4063        }
4064    }
4065    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
4066        fidl::encoding::Encode<BrowseControllerSetBrowsedPlayerRequest, D> for (T0,)
4067    {
4068        #[inline]
4069        unsafe fn encode(
4070            self,
4071            encoder: &mut fidl::encoding::Encoder<'_, D>,
4072            offset: usize,
4073            depth: fidl::encoding::Depth,
4074        ) -> fidl::Result<()> {
4075            encoder.debug_check_bounds::<BrowseControllerSetBrowsedPlayerRequest>(offset);
4076            // Zero out padding regions. There's no need to apply masks
4077            // because the unmasked parts will be overwritten by fields.
4078            // Write the fields.
4079            self.0.encode(encoder, offset + 0, depth)?;
4080            Ok(())
4081        }
4082    }
4083
4084    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4085        for BrowseControllerSetBrowsedPlayerRequest
4086    {
4087        #[inline(always)]
4088        fn new_empty() -> Self {
4089            Self { player_id: fidl::new_empty!(u16, D) }
4090        }
4091
4092        #[inline]
4093        unsafe fn decode(
4094            &mut self,
4095            decoder: &mut fidl::encoding::Decoder<'_, D>,
4096            offset: usize,
4097            _depth: fidl::encoding::Depth,
4098        ) -> fidl::Result<()> {
4099            decoder.debug_check_bounds::<Self>(offset);
4100            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4101            // Verify that padding bytes are zero.
4102            // Copy from the buffer into the object.
4103            unsafe {
4104                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
4105            }
4106            Ok(())
4107        }
4108    }
4109
4110    impl fidl::encoding::ValueTypeMarker for BrowseControllerChangePathResponse {
4111        type Borrowed<'a> = &'a Self;
4112        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4113            value
4114        }
4115    }
4116
4117    unsafe impl fidl::encoding::TypeMarker for BrowseControllerChangePathResponse {
4118        type Owned = Self;
4119
4120        #[inline(always)]
4121        fn inline_align(_context: fidl::encoding::Context) -> usize {
4122            4
4123        }
4124
4125        #[inline(always)]
4126        fn inline_size(_context: fidl::encoding::Context) -> usize {
4127            4
4128        }
4129        #[inline(always)]
4130        fn encode_is_copy() -> bool {
4131            true
4132        }
4133
4134        #[inline(always)]
4135        fn decode_is_copy() -> bool {
4136            true
4137        }
4138    }
4139
4140    unsafe impl<D: fidl::encoding::ResourceDialect>
4141        fidl::encoding::Encode<BrowseControllerChangePathResponse, D>
4142        for &BrowseControllerChangePathResponse
4143    {
4144        #[inline]
4145        unsafe fn encode(
4146            self,
4147            encoder: &mut fidl::encoding::Encoder<'_, D>,
4148            offset: usize,
4149            _depth: fidl::encoding::Depth,
4150        ) -> fidl::Result<()> {
4151            encoder.debug_check_bounds::<BrowseControllerChangePathResponse>(offset);
4152            unsafe {
4153                // Copy the object into the buffer.
4154                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4155                (buf_ptr as *mut BrowseControllerChangePathResponse)
4156                    .write_unaligned((self as *const BrowseControllerChangePathResponse).read());
4157                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
4158                // done second because the memcpy will write garbage to these bytes.
4159            }
4160            Ok(())
4161        }
4162    }
4163    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
4164        fidl::encoding::Encode<BrowseControllerChangePathResponse, D> for (T0,)
4165    {
4166        #[inline]
4167        unsafe fn encode(
4168            self,
4169            encoder: &mut fidl::encoding::Encoder<'_, D>,
4170            offset: usize,
4171            depth: fidl::encoding::Depth,
4172        ) -> fidl::Result<()> {
4173            encoder.debug_check_bounds::<BrowseControllerChangePathResponse>(offset);
4174            // Zero out padding regions. There's no need to apply masks
4175            // because the unmasked parts will be overwritten by fields.
4176            // Write the fields.
4177            self.0.encode(encoder, offset + 0, depth)?;
4178            Ok(())
4179        }
4180    }
4181
4182    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4183        for BrowseControllerChangePathResponse
4184    {
4185        #[inline(always)]
4186        fn new_empty() -> Self {
4187            Self { num_items: fidl::new_empty!(u32, D) }
4188        }
4189
4190        #[inline]
4191        unsafe fn decode(
4192            &mut self,
4193            decoder: &mut fidl::encoding::Decoder<'_, D>,
4194            offset: usize,
4195            _depth: fidl::encoding::Depth,
4196        ) -> fidl::Result<()> {
4197            decoder.debug_check_bounds::<Self>(offset);
4198            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4199            // Verify that padding bytes are zero.
4200            // Copy from the buffer into the object.
4201            unsafe {
4202                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
4203            }
4204            Ok(())
4205        }
4206    }
4207
4208    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetFileSystemItemsResponse {
4209        type Borrowed<'a> = &'a Self;
4210        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4211            value
4212        }
4213    }
4214
4215    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetFileSystemItemsResponse {
4216        type Owned = Self;
4217
4218        #[inline(always)]
4219        fn inline_align(_context: fidl::encoding::Context) -> usize {
4220            8
4221        }
4222
4223        #[inline(always)]
4224        fn inline_size(_context: fidl::encoding::Context) -> usize {
4225            16
4226        }
4227    }
4228
4229    unsafe impl<D: fidl::encoding::ResourceDialect>
4230        fidl::encoding::Encode<BrowseControllerGetFileSystemItemsResponse, D>
4231        for &BrowseControllerGetFileSystemItemsResponse
4232    {
4233        #[inline]
4234        unsafe fn encode(
4235            self,
4236            encoder: &mut fidl::encoding::Encoder<'_, D>,
4237            offset: usize,
4238            _depth: fidl::encoding::Depth,
4239        ) -> fidl::Result<()> {
4240            encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsResponse>(offset);
4241            // Delegate to tuple encoding.
4242            fidl::encoding::Encode::<BrowseControllerGetFileSystemItemsResponse, D>::encode(
4243                (
4244                    <fidl::encoding::Vector<FileSystemItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4245                ),
4246                encoder, offset, _depth
4247            )
4248        }
4249    }
4250    unsafe impl<
4251            D: fidl::encoding::ResourceDialect,
4252            T0: fidl::encoding::Encode<fidl::encoding::Vector<FileSystemItem, 16>, D>,
4253        > fidl::encoding::Encode<BrowseControllerGetFileSystemItemsResponse, D> for (T0,)
4254    {
4255        #[inline]
4256        unsafe fn encode(
4257            self,
4258            encoder: &mut fidl::encoding::Encoder<'_, D>,
4259            offset: usize,
4260            depth: fidl::encoding::Depth,
4261        ) -> fidl::Result<()> {
4262            encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsResponse>(offset);
4263            // Zero out padding regions. There's no need to apply masks
4264            // because the unmasked parts will be overwritten by fields.
4265            // Write the fields.
4266            self.0.encode(encoder, offset + 0, depth)?;
4267            Ok(())
4268        }
4269    }
4270
4271    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4272        for BrowseControllerGetFileSystemItemsResponse
4273    {
4274        #[inline(always)]
4275        fn new_empty() -> Self {
4276            Self { items: fidl::new_empty!(fidl::encoding::Vector<FileSystemItem, 16>, D) }
4277        }
4278
4279        #[inline]
4280        unsafe fn decode(
4281            &mut self,
4282            decoder: &mut fidl::encoding::Decoder<'_, D>,
4283            offset: usize,
4284            _depth: fidl::encoding::Depth,
4285        ) -> fidl::Result<()> {
4286            decoder.debug_check_bounds::<Self>(offset);
4287            // Verify that padding bytes are zero.
4288            fidl::decode!(fidl::encoding::Vector<FileSystemItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4289            Ok(())
4290        }
4291    }
4292
4293    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetMediaPlayerItemsResponse {
4294        type Borrowed<'a> = &'a Self;
4295        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4296            value
4297        }
4298    }
4299
4300    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetMediaPlayerItemsResponse {
4301        type Owned = Self;
4302
4303        #[inline(always)]
4304        fn inline_align(_context: fidl::encoding::Context) -> usize {
4305            8
4306        }
4307
4308        #[inline(always)]
4309        fn inline_size(_context: fidl::encoding::Context) -> usize {
4310            16
4311        }
4312    }
4313
4314    unsafe impl<D: fidl::encoding::ResourceDialect>
4315        fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsResponse, D>
4316        for &BrowseControllerGetMediaPlayerItemsResponse
4317    {
4318        #[inline]
4319        unsafe fn encode(
4320            self,
4321            encoder: &mut fidl::encoding::Encoder<'_, D>,
4322            offset: usize,
4323            _depth: fidl::encoding::Depth,
4324        ) -> fidl::Result<()> {
4325            encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsResponse>(offset);
4326            // Delegate to tuple encoding.
4327            fidl::encoding::Encode::<BrowseControllerGetMediaPlayerItemsResponse, D>::encode(
4328                (
4329                    <fidl::encoding::Vector<MediaPlayerItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4330                ),
4331                encoder, offset, _depth
4332            )
4333        }
4334    }
4335    unsafe impl<
4336            D: fidl::encoding::ResourceDialect,
4337            T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaPlayerItem, 16>, D>,
4338        > fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsResponse, D> for (T0,)
4339    {
4340        #[inline]
4341        unsafe fn encode(
4342            self,
4343            encoder: &mut fidl::encoding::Encoder<'_, D>,
4344            offset: usize,
4345            depth: fidl::encoding::Depth,
4346        ) -> fidl::Result<()> {
4347            encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsResponse>(offset);
4348            // Zero out padding regions. There's no need to apply masks
4349            // because the unmasked parts will be overwritten by fields.
4350            // Write the fields.
4351            self.0.encode(encoder, offset + 0, depth)?;
4352            Ok(())
4353        }
4354    }
4355
4356    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4357        for BrowseControllerGetMediaPlayerItemsResponse
4358    {
4359        #[inline(always)]
4360        fn new_empty() -> Self {
4361            Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaPlayerItem, 16>, D) }
4362        }
4363
4364        #[inline]
4365        unsafe fn decode(
4366            &mut self,
4367            decoder: &mut fidl::encoding::Decoder<'_, D>,
4368            offset: usize,
4369            _depth: fidl::encoding::Depth,
4370        ) -> fidl::Result<()> {
4371            decoder.debug_check_bounds::<Self>(offset);
4372            // Verify that padding bytes are zero.
4373            fidl::decode!(fidl::encoding::Vector<MediaPlayerItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4374            Ok(())
4375        }
4376    }
4377
4378    impl fidl::encoding::ValueTypeMarker for BrowseControllerGetNowPlayingItemsResponse {
4379        type Borrowed<'a> = &'a Self;
4380        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4381            value
4382        }
4383    }
4384
4385    unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetNowPlayingItemsResponse {
4386        type Owned = Self;
4387
4388        #[inline(always)]
4389        fn inline_align(_context: fidl::encoding::Context) -> usize {
4390            8
4391        }
4392
4393        #[inline(always)]
4394        fn inline_size(_context: fidl::encoding::Context) -> usize {
4395            16
4396        }
4397    }
4398
4399    unsafe impl<D: fidl::encoding::ResourceDialect>
4400        fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsResponse, D>
4401        for &BrowseControllerGetNowPlayingItemsResponse
4402    {
4403        #[inline]
4404        unsafe fn encode(
4405            self,
4406            encoder: &mut fidl::encoding::Encoder<'_, D>,
4407            offset: usize,
4408            _depth: fidl::encoding::Depth,
4409        ) -> fidl::Result<()> {
4410            encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsResponse>(offset);
4411            // Delegate to tuple encoding.
4412            fidl::encoding::Encode::<BrowseControllerGetNowPlayingItemsResponse, D>::encode(
4413                (
4414                    <fidl::encoding::Vector<MediaElementItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4415                ),
4416                encoder, offset, _depth
4417            )
4418        }
4419    }
4420    unsafe impl<
4421            D: fidl::encoding::ResourceDialect,
4422            T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaElementItem, 16>, D>,
4423        > fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsResponse, D> for (T0,)
4424    {
4425        #[inline]
4426        unsafe fn encode(
4427            self,
4428            encoder: &mut fidl::encoding::Encoder<'_, D>,
4429            offset: usize,
4430            depth: fidl::encoding::Depth,
4431        ) -> fidl::Result<()> {
4432            encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsResponse>(offset);
4433            // Zero out padding regions. There's no need to apply masks
4434            // because the unmasked parts will be overwritten by fields.
4435            // Write the fields.
4436            self.0.encode(encoder, offset + 0, depth)?;
4437            Ok(())
4438        }
4439    }
4440
4441    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4442        for BrowseControllerGetNowPlayingItemsResponse
4443    {
4444        #[inline(always)]
4445        fn new_empty() -> Self {
4446            Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaElementItem, 16>, D) }
4447        }
4448
4449        #[inline]
4450        unsafe fn decode(
4451            &mut self,
4452            decoder: &mut fidl::encoding::Decoder<'_, D>,
4453            offset: usize,
4454            _depth: fidl::encoding::Depth,
4455        ) -> fidl::Result<()> {
4456            decoder.debug_check_bounds::<Self>(offset);
4457            // Verify that padding bytes are zero.
4458            fidl::decode!(fidl::encoding::Vector<MediaElementItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4459            Ok(())
4460        }
4461    }
4462
4463    impl fidl::encoding::ValueTypeMarker for ControllerGetPlayerApplicationSettingsRequest {
4464        type Borrowed<'a> = &'a Self;
4465        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4466            value
4467        }
4468    }
4469
4470    unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayerApplicationSettingsRequest {
4471        type Owned = Self;
4472
4473        #[inline(always)]
4474        fn inline_align(_context: fidl::encoding::Context) -> usize {
4475            8
4476        }
4477
4478        #[inline(always)]
4479        fn inline_size(_context: fidl::encoding::Context) -> usize {
4480            16
4481        }
4482    }
4483
4484    unsafe impl<D: fidl::encoding::ResourceDialect>
4485        fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsRequest, D>
4486        for &ControllerGetPlayerApplicationSettingsRequest
4487    {
4488        #[inline]
4489        unsafe fn encode(
4490            self,
4491            encoder: &mut fidl::encoding::Encoder<'_, D>,
4492            offset: usize,
4493            _depth: fidl::encoding::Depth,
4494        ) -> fidl::Result<()> {
4495            encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsRequest>(offset);
4496            // Delegate to tuple encoding.
4497            fidl::encoding::Encode::<ControllerGetPlayerApplicationSettingsRequest, D>::encode(
4498                (
4499                    <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attribute_ids),
4500                ),
4501                encoder, offset, _depth
4502            )
4503        }
4504    }
4505    unsafe impl<
4506            D: fidl::encoding::ResourceDialect,
4507            T0: fidl::encoding::Encode<
4508                fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
4509                D,
4510            >,
4511        > fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsRequest, D> for (T0,)
4512    {
4513        #[inline]
4514        unsafe fn encode(
4515            self,
4516            encoder: &mut fidl::encoding::Encoder<'_, D>,
4517            offset: usize,
4518            depth: fidl::encoding::Depth,
4519        ) -> fidl::Result<()> {
4520            encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsRequest>(offset);
4521            // Zero out padding regions. There's no need to apply masks
4522            // because the unmasked parts will be overwritten by fields.
4523            // Write the fields.
4524            self.0.encode(encoder, offset + 0, depth)?;
4525            Ok(())
4526        }
4527    }
4528
4529    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4530        for ControllerGetPlayerApplicationSettingsRequest
4531    {
4532        #[inline(always)]
4533        fn new_empty() -> Self {
4534            Self {
4535                attribute_ids: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
4536            }
4537        }
4538
4539        #[inline]
4540        unsafe fn decode(
4541            &mut self,
4542            decoder: &mut fidl::encoding::Decoder<'_, D>,
4543            offset: usize,
4544            _depth: fidl::encoding::Depth,
4545        ) -> fidl::Result<()> {
4546            decoder.debug_check_bounds::<Self>(offset);
4547            // Verify that padding bytes are zero.
4548            fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attribute_ids, decoder, offset + 0, _depth)?;
4549            Ok(())
4550        }
4551    }
4552
4553    impl fidl::encoding::ValueTypeMarker for ControllerInformBatteryStatusRequest {
4554        type Borrowed<'a> = &'a Self;
4555        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4556            value
4557        }
4558    }
4559
4560    unsafe impl fidl::encoding::TypeMarker for ControllerInformBatteryStatusRequest {
4561        type Owned = Self;
4562
4563        #[inline(always)]
4564        fn inline_align(_context: fidl::encoding::Context) -> usize {
4565            1
4566        }
4567
4568        #[inline(always)]
4569        fn inline_size(_context: fidl::encoding::Context) -> usize {
4570            1
4571        }
4572    }
4573
4574    unsafe impl<D: fidl::encoding::ResourceDialect>
4575        fidl::encoding::Encode<ControllerInformBatteryStatusRequest, D>
4576        for &ControllerInformBatteryStatusRequest
4577    {
4578        #[inline]
4579        unsafe fn encode(
4580            self,
4581            encoder: &mut fidl::encoding::Encoder<'_, D>,
4582            offset: usize,
4583            _depth: fidl::encoding::Depth,
4584        ) -> fidl::Result<()> {
4585            encoder.debug_check_bounds::<ControllerInformBatteryStatusRequest>(offset);
4586            // Delegate to tuple encoding.
4587            fidl::encoding::Encode::<ControllerInformBatteryStatusRequest, D>::encode(
4588                (<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.battery_status),),
4589                encoder,
4590                offset,
4591                _depth,
4592            )
4593        }
4594    }
4595    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BatteryStatus, D>>
4596        fidl::encoding::Encode<ControllerInformBatteryStatusRequest, D> for (T0,)
4597    {
4598        #[inline]
4599        unsafe fn encode(
4600            self,
4601            encoder: &mut fidl::encoding::Encoder<'_, D>,
4602            offset: usize,
4603            depth: fidl::encoding::Depth,
4604        ) -> fidl::Result<()> {
4605            encoder.debug_check_bounds::<ControllerInformBatteryStatusRequest>(offset);
4606            // Zero out padding regions. There's no need to apply masks
4607            // because the unmasked parts will be overwritten by fields.
4608            // Write the fields.
4609            self.0.encode(encoder, offset + 0, depth)?;
4610            Ok(())
4611        }
4612    }
4613
4614    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4615        for ControllerInformBatteryStatusRequest
4616    {
4617        #[inline(always)]
4618        fn new_empty() -> Self {
4619            Self { battery_status: fidl::new_empty!(BatteryStatus, D) }
4620        }
4621
4622        #[inline]
4623        unsafe fn decode(
4624            &mut self,
4625            decoder: &mut fidl::encoding::Decoder<'_, D>,
4626            offset: usize,
4627            _depth: fidl::encoding::Depth,
4628        ) -> fidl::Result<()> {
4629            decoder.debug_check_bounds::<Self>(offset);
4630            // Verify that padding bytes are zero.
4631            fidl::decode!(BatteryStatus, D, &mut self.battery_status, decoder, offset + 0, _depth)?;
4632            Ok(())
4633        }
4634    }
4635
4636    impl fidl::encoding::ValueTypeMarker for ControllerOnNotificationRequest {
4637        type Borrowed<'a> = &'a Self;
4638        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4639            value
4640        }
4641    }
4642
4643    unsafe impl fidl::encoding::TypeMarker for ControllerOnNotificationRequest {
4644        type Owned = Self;
4645
4646        #[inline(always)]
4647        fn inline_align(_context: fidl::encoding::Context) -> usize {
4648            8
4649        }
4650
4651        #[inline(always)]
4652        fn inline_size(_context: fidl::encoding::Context) -> usize {
4653            24
4654        }
4655    }
4656
4657    unsafe impl<D: fidl::encoding::ResourceDialect>
4658        fidl::encoding::Encode<ControllerOnNotificationRequest, D>
4659        for &ControllerOnNotificationRequest
4660    {
4661        #[inline]
4662        unsafe fn encode(
4663            self,
4664            encoder: &mut fidl::encoding::Encoder<'_, D>,
4665            offset: usize,
4666            _depth: fidl::encoding::Depth,
4667        ) -> fidl::Result<()> {
4668            encoder.debug_check_bounds::<ControllerOnNotificationRequest>(offset);
4669            // Delegate to tuple encoding.
4670            fidl::encoding::Encode::<ControllerOnNotificationRequest, D>::encode(
4671                (
4672                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
4673                    <Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.notification),
4674                ),
4675                encoder,
4676                offset,
4677                _depth,
4678            )
4679        }
4680    }
4681    unsafe impl<
4682            D: fidl::encoding::ResourceDialect,
4683            T0: fidl::encoding::Encode<i64, D>,
4684            T1: fidl::encoding::Encode<Notification, D>,
4685        > fidl::encoding::Encode<ControllerOnNotificationRequest, D> for (T0, T1)
4686    {
4687        #[inline]
4688        unsafe fn encode(
4689            self,
4690            encoder: &mut fidl::encoding::Encoder<'_, D>,
4691            offset: usize,
4692            depth: fidl::encoding::Depth,
4693        ) -> fidl::Result<()> {
4694            encoder.debug_check_bounds::<ControllerOnNotificationRequest>(offset);
4695            // Zero out padding regions. There's no need to apply masks
4696            // because the unmasked parts will be overwritten by fields.
4697            // Write the fields.
4698            self.0.encode(encoder, offset + 0, depth)?;
4699            self.1.encode(encoder, offset + 8, depth)?;
4700            Ok(())
4701        }
4702    }
4703
4704    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4705        for ControllerOnNotificationRequest
4706    {
4707        #[inline(always)]
4708        fn new_empty() -> Self {
4709            Self {
4710                timestamp: fidl::new_empty!(i64, D),
4711                notification: fidl::new_empty!(Notification, D),
4712            }
4713        }
4714
4715        #[inline]
4716        unsafe fn decode(
4717            &mut self,
4718            decoder: &mut fidl::encoding::Decoder<'_, D>,
4719            offset: usize,
4720            _depth: fidl::encoding::Depth,
4721        ) -> fidl::Result<()> {
4722            decoder.debug_check_bounds::<Self>(offset);
4723            // Verify that padding bytes are zero.
4724            fidl::decode!(i64, D, &mut self.timestamp, decoder, offset + 0, _depth)?;
4725            fidl::decode!(Notification, D, &mut self.notification, decoder, offset + 8, _depth)?;
4726            Ok(())
4727        }
4728    }
4729
4730    impl fidl::encoding::ValueTypeMarker for ControllerSendCommandRequest {
4731        type Borrowed<'a> = &'a Self;
4732        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4733            value
4734        }
4735    }
4736
4737    unsafe impl fidl::encoding::TypeMarker for ControllerSendCommandRequest {
4738        type Owned = Self;
4739
4740        #[inline(always)]
4741        fn inline_align(_context: fidl::encoding::Context) -> usize {
4742            1
4743        }
4744
4745        #[inline(always)]
4746        fn inline_size(_context: fidl::encoding::Context) -> usize {
4747            1
4748        }
4749    }
4750
4751    unsafe impl<D: fidl::encoding::ResourceDialect>
4752        fidl::encoding::Encode<ControllerSendCommandRequest, D> for &ControllerSendCommandRequest
4753    {
4754        #[inline]
4755        unsafe fn encode(
4756            self,
4757            encoder: &mut fidl::encoding::Encoder<'_, D>,
4758            offset: usize,
4759            _depth: fidl::encoding::Depth,
4760        ) -> fidl::Result<()> {
4761            encoder.debug_check_bounds::<ControllerSendCommandRequest>(offset);
4762            // Delegate to tuple encoding.
4763            fidl::encoding::Encode::<ControllerSendCommandRequest, D>::encode(
4764                (<AvcPanelCommand as fidl::encoding::ValueTypeMarker>::borrow(&self.command),),
4765                encoder,
4766                offset,
4767                _depth,
4768            )
4769        }
4770    }
4771    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AvcPanelCommand, D>>
4772        fidl::encoding::Encode<ControllerSendCommandRequest, D> for (T0,)
4773    {
4774        #[inline]
4775        unsafe fn encode(
4776            self,
4777            encoder: &mut fidl::encoding::Encoder<'_, D>,
4778            offset: usize,
4779            depth: fidl::encoding::Depth,
4780        ) -> fidl::Result<()> {
4781            encoder.debug_check_bounds::<ControllerSendCommandRequest>(offset);
4782            // Zero out padding regions. There's no need to apply masks
4783            // because the unmasked parts will be overwritten by fields.
4784            // Write the fields.
4785            self.0.encode(encoder, offset + 0, depth)?;
4786            Ok(())
4787        }
4788    }
4789
4790    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4791        for ControllerSendCommandRequest
4792    {
4793        #[inline(always)]
4794        fn new_empty() -> Self {
4795            Self { command: fidl::new_empty!(AvcPanelCommand, D) }
4796        }
4797
4798        #[inline]
4799        unsafe fn decode(
4800            &mut self,
4801            decoder: &mut fidl::encoding::Decoder<'_, D>,
4802            offset: usize,
4803            _depth: fidl::encoding::Depth,
4804        ) -> fidl::Result<()> {
4805            decoder.debug_check_bounds::<Self>(offset);
4806            // Verify that padding bytes are zero.
4807            fidl::decode!(AvcPanelCommand, D, &mut self.command, decoder, offset + 0, _depth)?;
4808            Ok(())
4809        }
4810    }
4811
4812    impl fidl::encoding::ValueTypeMarker for ControllerSetAbsoluteVolumeRequest {
4813        type Borrowed<'a> = &'a Self;
4814        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4815            value
4816        }
4817    }
4818
4819    unsafe impl fidl::encoding::TypeMarker for ControllerSetAbsoluteVolumeRequest {
4820        type Owned = Self;
4821
4822        #[inline(always)]
4823        fn inline_align(_context: fidl::encoding::Context) -> usize {
4824            1
4825        }
4826
4827        #[inline(always)]
4828        fn inline_size(_context: fidl::encoding::Context) -> usize {
4829            1
4830        }
4831        #[inline(always)]
4832        fn encode_is_copy() -> bool {
4833            true
4834        }
4835
4836        #[inline(always)]
4837        fn decode_is_copy() -> bool {
4838            true
4839        }
4840    }
4841
4842    unsafe impl<D: fidl::encoding::ResourceDialect>
4843        fidl::encoding::Encode<ControllerSetAbsoluteVolumeRequest, D>
4844        for &ControllerSetAbsoluteVolumeRequest
4845    {
4846        #[inline]
4847        unsafe fn encode(
4848            self,
4849            encoder: &mut fidl::encoding::Encoder<'_, D>,
4850            offset: usize,
4851            _depth: fidl::encoding::Depth,
4852        ) -> fidl::Result<()> {
4853            encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeRequest>(offset);
4854            unsafe {
4855                // Copy the object into the buffer.
4856                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4857                (buf_ptr as *mut ControllerSetAbsoluteVolumeRequest)
4858                    .write_unaligned((self as *const ControllerSetAbsoluteVolumeRequest).read());
4859                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
4860                // done second because the memcpy will write garbage to these bytes.
4861            }
4862            Ok(())
4863        }
4864    }
4865    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
4866        fidl::encoding::Encode<ControllerSetAbsoluteVolumeRequest, D> for (T0,)
4867    {
4868        #[inline]
4869        unsafe fn encode(
4870            self,
4871            encoder: &mut fidl::encoding::Encoder<'_, D>,
4872            offset: usize,
4873            depth: fidl::encoding::Depth,
4874        ) -> fidl::Result<()> {
4875            encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeRequest>(offset);
4876            // Zero out padding regions. There's no need to apply masks
4877            // because the unmasked parts will be overwritten by fields.
4878            // Write the fields.
4879            self.0.encode(encoder, offset + 0, depth)?;
4880            Ok(())
4881        }
4882    }
4883
4884    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4885        for ControllerSetAbsoluteVolumeRequest
4886    {
4887        #[inline(always)]
4888        fn new_empty() -> Self {
4889            Self { requested_volume: fidl::new_empty!(u8, D) }
4890        }
4891
4892        #[inline]
4893        unsafe fn decode(
4894            &mut self,
4895            decoder: &mut fidl::encoding::Decoder<'_, D>,
4896            offset: usize,
4897            _depth: fidl::encoding::Depth,
4898        ) -> fidl::Result<()> {
4899            decoder.debug_check_bounds::<Self>(offset);
4900            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4901            // Verify that padding bytes are zero.
4902            // Copy from the buffer into the object.
4903            unsafe {
4904                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
4905            }
4906            Ok(())
4907        }
4908    }
4909
4910    impl fidl::encoding::ValueTypeMarker for ControllerSetAddressedPlayerRequest {
4911        type Borrowed<'a> = &'a Self;
4912        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4913            value
4914        }
4915    }
4916
4917    unsafe impl fidl::encoding::TypeMarker for ControllerSetAddressedPlayerRequest {
4918        type Owned = Self;
4919
4920        #[inline(always)]
4921        fn inline_align(_context: fidl::encoding::Context) -> usize {
4922            2
4923        }
4924
4925        #[inline(always)]
4926        fn inline_size(_context: fidl::encoding::Context) -> usize {
4927            2
4928        }
4929        #[inline(always)]
4930        fn encode_is_copy() -> bool {
4931            true
4932        }
4933
4934        #[inline(always)]
4935        fn decode_is_copy() -> bool {
4936            true
4937        }
4938    }
4939
4940    unsafe impl<D: fidl::encoding::ResourceDialect>
4941        fidl::encoding::Encode<ControllerSetAddressedPlayerRequest, D>
4942        for &ControllerSetAddressedPlayerRequest
4943    {
4944        #[inline]
4945        unsafe fn encode(
4946            self,
4947            encoder: &mut fidl::encoding::Encoder<'_, D>,
4948            offset: usize,
4949            _depth: fidl::encoding::Depth,
4950        ) -> fidl::Result<()> {
4951            encoder.debug_check_bounds::<ControllerSetAddressedPlayerRequest>(offset);
4952            unsafe {
4953                // Copy the object into the buffer.
4954                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4955                (buf_ptr as *mut ControllerSetAddressedPlayerRequest)
4956                    .write_unaligned((self as *const ControllerSetAddressedPlayerRequest).read());
4957                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
4958                // done second because the memcpy will write garbage to these bytes.
4959            }
4960            Ok(())
4961        }
4962    }
4963    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
4964        fidl::encoding::Encode<ControllerSetAddressedPlayerRequest, D> for (T0,)
4965    {
4966        #[inline]
4967        unsafe fn encode(
4968            self,
4969            encoder: &mut fidl::encoding::Encoder<'_, D>,
4970            offset: usize,
4971            depth: fidl::encoding::Depth,
4972        ) -> fidl::Result<()> {
4973            encoder.debug_check_bounds::<ControllerSetAddressedPlayerRequest>(offset);
4974            // Zero out padding regions. There's no need to apply masks
4975            // because the unmasked parts will be overwritten by fields.
4976            // Write the fields.
4977            self.0.encode(encoder, offset + 0, depth)?;
4978            Ok(())
4979        }
4980    }
4981
4982    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4983        for ControllerSetAddressedPlayerRequest
4984    {
4985        #[inline(always)]
4986        fn new_empty() -> Self {
4987            Self { player_id: fidl::new_empty!(u16, D) }
4988        }
4989
4990        #[inline]
4991        unsafe fn decode(
4992            &mut self,
4993            decoder: &mut fidl::encoding::Decoder<'_, D>,
4994            offset: usize,
4995            _depth: fidl::encoding::Depth,
4996        ) -> fidl::Result<()> {
4997            decoder.debug_check_bounds::<Self>(offset);
4998            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4999            // Verify that padding bytes are zero.
5000            // Copy from the buffer into the object.
5001            unsafe {
5002                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
5003            }
5004            Ok(())
5005        }
5006    }
5007
5008    impl fidl::encoding::ValueTypeMarker for ControllerSetNotificationFilterRequest {
5009        type Borrowed<'a> = &'a Self;
5010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5011            value
5012        }
5013    }
5014
5015    unsafe impl fidl::encoding::TypeMarker for ControllerSetNotificationFilterRequest {
5016        type Owned = Self;
5017
5018        #[inline(always)]
5019        fn inline_align(_context: fidl::encoding::Context) -> usize {
5020            4
5021        }
5022
5023        #[inline(always)]
5024        fn inline_size(_context: fidl::encoding::Context) -> usize {
5025            8
5026        }
5027    }
5028
5029    unsafe impl<D: fidl::encoding::ResourceDialect>
5030        fidl::encoding::Encode<ControllerSetNotificationFilterRequest, D>
5031        for &ControllerSetNotificationFilterRequest
5032    {
5033        #[inline]
5034        unsafe fn encode(
5035            self,
5036            encoder: &mut fidl::encoding::Encoder<'_, D>,
5037            offset: usize,
5038            _depth: fidl::encoding::Depth,
5039        ) -> fidl::Result<()> {
5040            encoder.debug_check_bounds::<ControllerSetNotificationFilterRequest>(offset);
5041            // Delegate to tuple encoding.
5042            fidl::encoding::Encode::<ControllerSetNotificationFilterRequest, D>::encode(
5043                (
5044                    <Notifications as fidl::encoding::ValueTypeMarker>::borrow(&self.notifications),
5045                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(
5046                        &self.position_change_interval,
5047                    ),
5048                ),
5049                encoder,
5050                offset,
5051                _depth,
5052            )
5053        }
5054    }
5055    unsafe impl<
5056            D: fidl::encoding::ResourceDialect,
5057            T0: fidl::encoding::Encode<Notifications, D>,
5058            T1: fidl::encoding::Encode<u32, D>,
5059        > fidl::encoding::Encode<ControllerSetNotificationFilterRequest, D> for (T0, T1)
5060    {
5061        #[inline]
5062        unsafe fn encode(
5063            self,
5064            encoder: &mut fidl::encoding::Encoder<'_, D>,
5065            offset: usize,
5066            depth: fidl::encoding::Depth,
5067        ) -> fidl::Result<()> {
5068            encoder.debug_check_bounds::<ControllerSetNotificationFilterRequest>(offset);
5069            // Zero out padding regions. There's no need to apply masks
5070            // because the unmasked parts will be overwritten by fields.
5071            // Write the fields.
5072            self.0.encode(encoder, offset + 0, depth)?;
5073            self.1.encode(encoder, offset + 4, depth)?;
5074            Ok(())
5075        }
5076    }
5077
5078    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5079        for ControllerSetNotificationFilterRequest
5080    {
5081        #[inline(always)]
5082        fn new_empty() -> Self {
5083            Self {
5084                notifications: fidl::new_empty!(Notifications, D),
5085                position_change_interval: fidl::new_empty!(u32, D),
5086            }
5087        }
5088
5089        #[inline]
5090        unsafe fn decode(
5091            &mut self,
5092            decoder: &mut fidl::encoding::Decoder<'_, D>,
5093            offset: usize,
5094            _depth: fidl::encoding::Depth,
5095        ) -> fidl::Result<()> {
5096            decoder.debug_check_bounds::<Self>(offset);
5097            // Verify that padding bytes are zero.
5098            fidl::decode!(Notifications, D, &mut self.notifications, decoder, offset + 0, _depth)?;
5099            fidl::decode!(u32, D, &mut self.position_change_interval, decoder, offset + 4, _depth)?;
5100            Ok(())
5101        }
5102    }
5103
5104    impl fidl::encoding::ValueTypeMarker for ControllerSetPlayerApplicationSettingsRequest {
5105        type Borrowed<'a> = &'a Self;
5106        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5107            value
5108        }
5109    }
5110
5111    unsafe impl fidl::encoding::TypeMarker for ControllerSetPlayerApplicationSettingsRequest {
5112        type Owned = Self;
5113
5114        #[inline(always)]
5115        fn inline_align(_context: fidl::encoding::Context) -> usize {
5116            8
5117        }
5118
5119        #[inline(always)]
5120        fn inline_size(_context: fidl::encoding::Context) -> usize {
5121            16
5122        }
5123    }
5124
5125    unsafe impl<D: fidl::encoding::ResourceDialect>
5126        fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsRequest, D>
5127        for &ControllerSetPlayerApplicationSettingsRequest
5128    {
5129        #[inline]
5130        unsafe fn encode(
5131            self,
5132            encoder: &mut fidl::encoding::Encoder<'_, D>,
5133            offset: usize,
5134            _depth: fidl::encoding::Depth,
5135        ) -> fidl::Result<()> {
5136            encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsRequest>(offset);
5137            // Delegate to tuple encoding.
5138            fidl::encoding::Encode::<ControllerSetPlayerApplicationSettingsRequest, D>::encode(
5139                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5140                    &self.requested_settings,
5141                ),),
5142                encoder,
5143                offset,
5144                _depth,
5145            )
5146        }
5147    }
5148    unsafe impl<
5149            D: fidl::encoding::ResourceDialect,
5150            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5151        > fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsRequest, D> for (T0,)
5152    {
5153        #[inline]
5154        unsafe fn encode(
5155            self,
5156            encoder: &mut fidl::encoding::Encoder<'_, D>,
5157            offset: usize,
5158            depth: fidl::encoding::Depth,
5159        ) -> fidl::Result<()> {
5160            encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsRequest>(offset);
5161            // Zero out padding regions. There's no need to apply masks
5162            // because the unmasked parts will be overwritten by fields.
5163            // Write the fields.
5164            self.0.encode(encoder, offset + 0, depth)?;
5165            Ok(())
5166        }
5167    }
5168
5169    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5170        for ControllerSetPlayerApplicationSettingsRequest
5171    {
5172        #[inline(always)]
5173        fn new_empty() -> Self {
5174            Self { requested_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5175        }
5176
5177        #[inline]
5178        unsafe fn decode(
5179            &mut self,
5180            decoder: &mut fidl::encoding::Decoder<'_, D>,
5181            offset: usize,
5182            _depth: fidl::encoding::Depth,
5183        ) -> fidl::Result<()> {
5184            decoder.debug_check_bounds::<Self>(offset);
5185            // Verify that padding bytes are zero.
5186            fidl::decode!(
5187                PlayerApplicationSettings,
5188                D,
5189                &mut self.requested_settings,
5190                decoder,
5191                offset + 0,
5192                _depth
5193            )?;
5194            Ok(())
5195        }
5196    }
5197
5198    impl fidl::encoding::ValueTypeMarker for ControllerGetMediaAttributesResponse {
5199        type Borrowed<'a> = &'a Self;
5200        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5201            value
5202        }
5203    }
5204
5205    unsafe impl fidl::encoding::TypeMarker for ControllerGetMediaAttributesResponse {
5206        type Owned = Self;
5207
5208        #[inline(always)]
5209        fn inline_align(_context: fidl::encoding::Context) -> usize {
5210            8
5211        }
5212
5213        #[inline(always)]
5214        fn inline_size(_context: fidl::encoding::Context) -> usize {
5215            16
5216        }
5217    }
5218
5219    unsafe impl<D: fidl::encoding::ResourceDialect>
5220        fidl::encoding::Encode<ControllerGetMediaAttributesResponse, D>
5221        for &ControllerGetMediaAttributesResponse
5222    {
5223        #[inline]
5224        unsafe fn encode(
5225            self,
5226            encoder: &mut fidl::encoding::Encoder<'_, D>,
5227            offset: usize,
5228            _depth: fidl::encoding::Depth,
5229        ) -> fidl::Result<()> {
5230            encoder.debug_check_bounds::<ControllerGetMediaAttributesResponse>(offset);
5231            // Delegate to tuple encoding.
5232            fidl::encoding::Encode::<ControllerGetMediaAttributesResponse, D>::encode(
5233                (<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),),
5234                encoder,
5235                offset,
5236                _depth,
5237            )
5238        }
5239    }
5240    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MediaAttributes, D>>
5241        fidl::encoding::Encode<ControllerGetMediaAttributesResponse, D> for (T0,)
5242    {
5243        #[inline]
5244        unsafe fn encode(
5245            self,
5246            encoder: &mut fidl::encoding::Encoder<'_, D>,
5247            offset: usize,
5248            depth: fidl::encoding::Depth,
5249        ) -> fidl::Result<()> {
5250            encoder.debug_check_bounds::<ControllerGetMediaAttributesResponse>(offset);
5251            // Zero out padding regions. There's no need to apply masks
5252            // because the unmasked parts will be overwritten by fields.
5253            // Write the fields.
5254            self.0.encode(encoder, offset + 0, depth)?;
5255            Ok(())
5256        }
5257    }
5258
5259    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5260        for ControllerGetMediaAttributesResponse
5261    {
5262        #[inline(always)]
5263        fn new_empty() -> Self {
5264            Self { attributes: fidl::new_empty!(MediaAttributes, D) }
5265        }
5266
5267        #[inline]
5268        unsafe fn decode(
5269            &mut self,
5270            decoder: &mut fidl::encoding::Decoder<'_, D>,
5271            offset: usize,
5272            _depth: fidl::encoding::Depth,
5273        ) -> fidl::Result<()> {
5274            decoder.debug_check_bounds::<Self>(offset);
5275            // Verify that padding bytes are zero.
5276            fidl::decode!(MediaAttributes, D, &mut self.attributes, decoder, offset + 0, _depth)?;
5277            Ok(())
5278        }
5279    }
5280
5281    impl fidl::encoding::ValueTypeMarker for ControllerGetPlayStatusResponse {
5282        type Borrowed<'a> = &'a Self;
5283        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5284            value
5285        }
5286    }
5287
5288    unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayStatusResponse {
5289        type Owned = Self;
5290
5291        #[inline(always)]
5292        fn inline_align(_context: fidl::encoding::Context) -> usize {
5293            8
5294        }
5295
5296        #[inline(always)]
5297        fn inline_size(_context: fidl::encoding::Context) -> usize {
5298            16
5299        }
5300    }
5301
5302    unsafe impl<D: fidl::encoding::ResourceDialect>
5303        fidl::encoding::Encode<ControllerGetPlayStatusResponse, D>
5304        for &ControllerGetPlayStatusResponse
5305    {
5306        #[inline]
5307        unsafe fn encode(
5308            self,
5309            encoder: &mut fidl::encoding::Encoder<'_, D>,
5310            offset: usize,
5311            _depth: fidl::encoding::Depth,
5312        ) -> fidl::Result<()> {
5313            encoder.debug_check_bounds::<ControllerGetPlayStatusResponse>(offset);
5314            // Delegate to tuple encoding.
5315            fidl::encoding::Encode::<ControllerGetPlayStatusResponse, D>::encode(
5316                (<PlayStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.play_status),),
5317                encoder,
5318                offset,
5319                _depth,
5320            )
5321        }
5322    }
5323    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PlayStatus, D>>
5324        fidl::encoding::Encode<ControllerGetPlayStatusResponse, D> for (T0,)
5325    {
5326        #[inline]
5327        unsafe fn encode(
5328            self,
5329            encoder: &mut fidl::encoding::Encoder<'_, D>,
5330            offset: usize,
5331            depth: fidl::encoding::Depth,
5332        ) -> fidl::Result<()> {
5333            encoder.debug_check_bounds::<ControllerGetPlayStatusResponse>(offset);
5334            // Zero out padding regions. There's no need to apply masks
5335            // because the unmasked parts will be overwritten by fields.
5336            // Write the fields.
5337            self.0.encode(encoder, offset + 0, depth)?;
5338            Ok(())
5339        }
5340    }
5341
5342    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5343        for ControllerGetPlayStatusResponse
5344    {
5345        #[inline(always)]
5346        fn new_empty() -> Self {
5347            Self { play_status: fidl::new_empty!(PlayStatus, D) }
5348        }
5349
5350        #[inline]
5351        unsafe fn decode(
5352            &mut self,
5353            decoder: &mut fidl::encoding::Decoder<'_, D>,
5354            offset: usize,
5355            _depth: fidl::encoding::Depth,
5356        ) -> fidl::Result<()> {
5357            decoder.debug_check_bounds::<Self>(offset);
5358            // Verify that padding bytes are zero.
5359            fidl::decode!(PlayStatus, D, &mut self.play_status, decoder, offset + 0, _depth)?;
5360            Ok(())
5361        }
5362    }
5363
5364    impl fidl::encoding::ValueTypeMarker for ControllerGetPlayerApplicationSettingsResponse {
5365        type Borrowed<'a> = &'a Self;
5366        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5367            value
5368        }
5369    }
5370
5371    unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayerApplicationSettingsResponse {
5372        type Owned = Self;
5373
5374        #[inline(always)]
5375        fn inline_align(_context: fidl::encoding::Context) -> usize {
5376            8
5377        }
5378
5379        #[inline(always)]
5380        fn inline_size(_context: fidl::encoding::Context) -> usize {
5381            16
5382        }
5383    }
5384
5385    unsafe impl<D: fidl::encoding::ResourceDialect>
5386        fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsResponse, D>
5387        for &ControllerGetPlayerApplicationSettingsResponse
5388    {
5389        #[inline]
5390        unsafe fn encode(
5391            self,
5392            encoder: &mut fidl::encoding::Encoder<'_, D>,
5393            offset: usize,
5394            _depth: fidl::encoding::Depth,
5395        ) -> fidl::Result<()> {
5396            encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsResponse>(offset);
5397            // Delegate to tuple encoding.
5398            fidl::encoding::Encode::<ControllerGetPlayerApplicationSettingsResponse, D>::encode(
5399                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5400                    &self.current_settings,
5401                ),),
5402                encoder,
5403                offset,
5404                _depth,
5405            )
5406        }
5407    }
5408    unsafe impl<
5409            D: fidl::encoding::ResourceDialect,
5410            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5411        > fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsResponse, D> for (T0,)
5412    {
5413        #[inline]
5414        unsafe fn encode(
5415            self,
5416            encoder: &mut fidl::encoding::Encoder<'_, D>,
5417            offset: usize,
5418            depth: fidl::encoding::Depth,
5419        ) -> fidl::Result<()> {
5420            encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsResponse>(offset);
5421            // Zero out padding regions. There's no need to apply masks
5422            // because the unmasked parts will be overwritten by fields.
5423            // Write the fields.
5424            self.0.encode(encoder, offset + 0, depth)?;
5425            Ok(())
5426        }
5427    }
5428
5429    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5430        for ControllerGetPlayerApplicationSettingsResponse
5431    {
5432        #[inline(always)]
5433        fn new_empty() -> Self {
5434            Self { current_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5435        }
5436
5437        #[inline]
5438        unsafe fn decode(
5439            &mut self,
5440            decoder: &mut fidl::encoding::Decoder<'_, D>,
5441            offset: usize,
5442            _depth: fidl::encoding::Depth,
5443        ) -> fidl::Result<()> {
5444            decoder.debug_check_bounds::<Self>(offset);
5445            // Verify that padding bytes are zero.
5446            fidl::decode!(
5447                PlayerApplicationSettings,
5448                D,
5449                &mut self.current_settings,
5450                decoder,
5451                offset + 0,
5452                _depth
5453            )?;
5454            Ok(())
5455        }
5456    }
5457
5458    impl fidl::encoding::ValueTypeMarker for ControllerSetAbsoluteVolumeResponse {
5459        type Borrowed<'a> = &'a Self;
5460        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5461            value
5462        }
5463    }
5464
5465    unsafe impl fidl::encoding::TypeMarker for ControllerSetAbsoluteVolumeResponse {
5466        type Owned = Self;
5467
5468        #[inline(always)]
5469        fn inline_align(_context: fidl::encoding::Context) -> usize {
5470            1
5471        }
5472
5473        #[inline(always)]
5474        fn inline_size(_context: fidl::encoding::Context) -> usize {
5475            1
5476        }
5477        #[inline(always)]
5478        fn encode_is_copy() -> bool {
5479            true
5480        }
5481
5482        #[inline(always)]
5483        fn decode_is_copy() -> bool {
5484            true
5485        }
5486    }
5487
5488    unsafe impl<D: fidl::encoding::ResourceDialect>
5489        fidl::encoding::Encode<ControllerSetAbsoluteVolumeResponse, D>
5490        for &ControllerSetAbsoluteVolumeResponse
5491    {
5492        #[inline]
5493        unsafe fn encode(
5494            self,
5495            encoder: &mut fidl::encoding::Encoder<'_, D>,
5496            offset: usize,
5497            _depth: fidl::encoding::Depth,
5498        ) -> fidl::Result<()> {
5499            encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeResponse>(offset);
5500            unsafe {
5501                // Copy the object into the buffer.
5502                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5503                (buf_ptr as *mut ControllerSetAbsoluteVolumeResponse)
5504                    .write_unaligned((self as *const ControllerSetAbsoluteVolumeResponse).read());
5505                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
5506                // done second because the memcpy will write garbage to these bytes.
5507            }
5508            Ok(())
5509        }
5510    }
5511    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
5512        fidl::encoding::Encode<ControllerSetAbsoluteVolumeResponse, D> for (T0,)
5513    {
5514        #[inline]
5515        unsafe fn encode(
5516            self,
5517            encoder: &mut fidl::encoding::Encoder<'_, D>,
5518            offset: usize,
5519            depth: fidl::encoding::Depth,
5520        ) -> fidl::Result<()> {
5521            encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeResponse>(offset);
5522            // Zero out padding regions. There's no need to apply masks
5523            // because the unmasked parts will be overwritten by fields.
5524            // Write the fields.
5525            self.0.encode(encoder, offset + 0, depth)?;
5526            Ok(())
5527        }
5528    }
5529
5530    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5531        for ControllerSetAbsoluteVolumeResponse
5532    {
5533        #[inline(always)]
5534        fn new_empty() -> Self {
5535            Self { set_volume: fidl::new_empty!(u8, D) }
5536        }
5537
5538        #[inline]
5539        unsafe fn decode(
5540            &mut self,
5541            decoder: &mut fidl::encoding::Decoder<'_, D>,
5542            offset: usize,
5543            _depth: fidl::encoding::Depth,
5544        ) -> fidl::Result<()> {
5545            decoder.debug_check_bounds::<Self>(offset);
5546            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5547            // Verify that padding bytes are zero.
5548            // Copy from the buffer into the object.
5549            unsafe {
5550                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
5551            }
5552            Ok(())
5553        }
5554    }
5555
5556    impl fidl::encoding::ValueTypeMarker for ControllerSetPlayerApplicationSettingsResponse {
5557        type Borrowed<'a> = &'a Self;
5558        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5559            value
5560        }
5561    }
5562
5563    unsafe impl fidl::encoding::TypeMarker for ControllerSetPlayerApplicationSettingsResponse {
5564        type Owned = Self;
5565
5566        #[inline(always)]
5567        fn inline_align(_context: fidl::encoding::Context) -> usize {
5568            8
5569        }
5570
5571        #[inline(always)]
5572        fn inline_size(_context: fidl::encoding::Context) -> usize {
5573            16
5574        }
5575    }
5576
5577    unsafe impl<D: fidl::encoding::ResourceDialect>
5578        fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsResponse, D>
5579        for &ControllerSetPlayerApplicationSettingsResponse
5580    {
5581        #[inline]
5582        unsafe fn encode(
5583            self,
5584            encoder: &mut fidl::encoding::Encoder<'_, D>,
5585            offset: usize,
5586            _depth: fidl::encoding::Depth,
5587        ) -> fidl::Result<()> {
5588            encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsResponse>(offset);
5589            // Delegate to tuple encoding.
5590            fidl::encoding::Encode::<ControllerSetPlayerApplicationSettingsResponse, D>::encode(
5591                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5592                    &self.set_settings,
5593                ),),
5594                encoder,
5595                offset,
5596                _depth,
5597            )
5598        }
5599    }
5600    unsafe impl<
5601            D: fidl::encoding::ResourceDialect,
5602            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5603        > fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsResponse, D> for (T0,)
5604    {
5605        #[inline]
5606        unsafe fn encode(
5607            self,
5608            encoder: &mut fidl::encoding::Encoder<'_, D>,
5609            offset: usize,
5610            depth: fidl::encoding::Depth,
5611        ) -> fidl::Result<()> {
5612            encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsResponse>(offset);
5613            // Zero out padding regions. There's no need to apply masks
5614            // because the unmasked parts will be overwritten by fields.
5615            // Write the fields.
5616            self.0.encode(encoder, offset + 0, depth)?;
5617            Ok(())
5618        }
5619    }
5620
5621    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5622        for ControllerSetPlayerApplicationSettingsResponse
5623    {
5624        #[inline(always)]
5625        fn new_empty() -> Self {
5626            Self { set_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5627        }
5628
5629        #[inline]
5630        unsafe fn decode(
5631            &mut self,
5632            decoder: &mut fidl::encoding::Decoder<'_, D>,
5633            offset: usize,
5634            _depth: fidl::encoding::Depth,
5635        ) -> fidl::Result<()> {
5636            decoder.debug_check_bounds::<Self>(offset);
5637            // Verify that padding bytes are zero.
5638            fidl::decode!(
5639                PlayerApplicationSettings,
5640                D,
5641                &mut self.set_settings,
5642                decoder,
5643                offset + 0,
5644                _depth
5645            )?;
5646            Ok(())
5647        }
5648    }
5649
5650    impl fidl::encoding::ValueTypeMarker for CustomAttributeValue {
5651        type Borrowed<'a> = &'a Self;
5652        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5653            value
5654        }
5655    }
5656
5657    unsafe impl fidl::encoding::TypeMarker for CustomAttributeValue {
5658        type Owned = Self;
5659
5660        #[inline(always)]
5661        fn inline_align(_context: fidl::encoding::Context) -> usize {
5662            8
5663        }
5664
5665        #[inline(always)]
5666        fn inline_size(_context: fidl::encoding::Context) -> usize {
5667            24
5668        }
5669    }
5670
5671    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CustomAttributeValue, D>
5672        for &CustomAttributeValue
5673    {
5674        #[inline]
5675        unsafe fn encode(
5676            self,
5677            encoder: &mut fidl::encoding::Encoder<'_, D>,
5678            offset: usize,
5679            _depth: fidl::encoding::Depth,
5680        ) -> fidl::Result<()> {
5681            encoder.debug_check_bounds::<CustomAttributeValue>(offset);
5682            // Delegate to tuple encoding.
5683            fidl::encoding::Encode::<CustomAttributeValue, D>::encode(
5684                (
5685                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
5686                        &self.description,
5687                    ),
5688                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
5689                ),
5690                encoder,
5691                offset,
5692                _depth,
5693            )
5694        }
5695    }
5696    unsafe impl<
5697            D: fidl::encoding::ResourceDialect,
5698            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
5699            T1: fidl::encoding::Encode<u8, D>,
5700        > fidl::encoding::Encode<CustomAttributeValue, D> for (T0, T1)
5701    {
5702        #[inline]
5703        unsafe fn encode(
5704            self,
5705            encoder: &mut fidl::encoding::Encoder<'_, D>,
5706            offset: usize,
5707            depth: fidl::encoding::Depth,
5708        ) -> fidl::Result<()> {
5709            encoder.debug_check_bounds::<CustomAttributeValue>(offset);
5710            // Zero out padding regions. There's no need to apply masks
5711            // because the unmasked parts will be overwritten by fields.
5712            unsafe {
5713                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
5714                (ptr as *mut u64).write_unaligned(0);
5715            }
5716            // Write the fields.
5717            self.0.encode(encoder, offset + 0, depth)?;
5718            self.1.encode(encoder, offset + 16, depth)?;
5719            Ok(())
5720        }
5721    }
5722
5723    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CustomAttributeValue {
5724        #[inline(always)]
5725        fn new_empty() -> Self {
5726            Self {
5727                description: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
5728                value: fidl::new_empty!(u8, D),
5729            }
5730        }
5731
5732        #[inline]
5733        unsafe fn decode(
5734            &mut self,
5735            decoder: &mut fidl::encoding::Decoder<'_, D>,
5736            offset: usize,
5737            _depth: fidl::encoding::Depth,
5738        ) -> fidl::Result<()> {
5739            decoder.debug_check_bounds::<Self>(offset);
5740            // Verify that padding bytes are zero.
5741            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
5742            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5743            let mask = 0xffffffffffffff00u64;
5744            let maskedval = padval & mask;
5745            if maskedval != 0 {
5746                return Err(fidl::Error::NonZeroPadding {
5747                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
5748                });
5749            }
5750            fidl::decode!(
5751                fidl::encoding::BoundedString<255>,
5752                D,
5753                &mut self.description,
5754                decoder,
5755                offset + 0,
5756                _depth
5757            )?;
5758            fidl::decode!(u8, D, &mut self.value, decoder, offset + 16, _depth)?;
5759            Ok(())
5760        }
5761    }
5762
5763    impl fidl::encoding::ValueTypeMarker for Parent {
5764        type Borrowed<'a> = &'a Self;
5765        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5766            value
5767        }
5768    }
5769
5770    unsafe impl fidl::encoding::TypeMarker for Parent {
5771        type Owned = Self;
5772
5773        #[inline(always)]
5774        fn inline_align(_context: fidl::encoding::Context) -> usize {
5775            1
5776        }
5777
5778        #[inline(always)]
5779        fn inline_size(_context: fidl::encoding::Context) -> usize {
5780            1
5781        }
5782    }
5783
5784    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parent, D> for &Parent {
5785        #[inline]
5786        unsafe fn encode(
5787            self,
5788            encoder: &mut fidl::encoding::Encoder<'_, D>,
5789            offset: usize,
5790            _depth: fidl::encoding::Depth,
5791        ) -> fidl::Result<()> {
5792            encoder.debug_check_bounds::<Parent>(offset);
5793            encoder.write_num(0u8, offset);
5794            Ok(())
5795        }
5796    }
5797
5798    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parent {
5799        #[inline(always)]
5800        fn new_empty() -> Self {
5801            Self
5802        }
5803
5804        #[inline]
5805        unsafe fn decode(
5806            &mut self,
5807            decoder: &mut fidl::encoding::Decoder<'_, D>,
5808            offset: usize,
5809            _depth: fidl::encoding::Depth,
5810        ) -> fidl::Result<()> {
5811            decoder.debug_check_bounds::<Self>(offset);
5812            match decoder.read_num::<u8>(offset) {
5813                0 => Ok(()),
5814                _ => Err(fidl::Error::Invalid),
5815            }
5816        }
5817    }
5818
5819    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetNotificationRequest {
5820        type Borrowed<'a> = &'a Self;
5821        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5822            value
5823        }
5824    }
5825
5826    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetNotificationRequest {
5827        type Owned = Self;
5828
5829        #[inline(always)]
5830        fn inline_align(_context: fidl::encoding::Context) -> usize {
5831            1
5832        }
5833
5834        #[inline(always)]
5835        fn inline_size(_context: fidl::encoding::Context) -> usize {
5836            1
5837        }
5838    }
5839
5840    unsafe impl<D: fidl::encoding::ResourceDialect>
5841        fidl::encoding::Encode<TargetHandlerGetNotificationRequest, D>
5842        for &TargetHandlerGetNotificationRequest
5843    {
5844        #[inline]
5845        unsafe fn encode(
5846            self,
5847            encoder: &mut fidl::encoding::Encoder<'_, D>,
5848            offset: usize,
5849            _depth: fidl::encoding::Depth,
5850        ) -> fidl::Result<()> {
5851            encoder.debug_check_bounds::<TargetHandlerGetNotificationRequest>(offset);
5852            // Delegate to tuple encoding.
5853            fidl::encoding::Encode::<TargetHandlerGetNotificationRequest, D>::encode(
5854                (<NotificationEvent as fidl::encoding::ValueTypeMarker>::borrow(&self.event_id),),
5855                encoder,
5856                offset,
5857                _depth,
5858            )
5859        }
5860    }
5861    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<NotificationEvent, D>>
5862        fidl::encoding::Encode<TargetHandlerGetNotificationRequest, D> for (T0,)
5863    {
5864        #[inline]
5865        unsafe fn encode(
5866            self,
5867            encoder: &mut fidl::encoding::Encoder<'_, D>,
5868            offset: usize,
5869            depth: fidl::encoding::Depth,
5870        ) -> fidl::Result<()> {
5871            encoder.debug_check_bounds::<TargetHandlerGetNotificationRequest>(offset);
5872            // Zero out padding regions. There's no need to apply masks
5873            // because the unmasked parts will be overwritten by fields.
5874            // Write the fields.
5875            self.0.encode(encoder, offset + 0, depth)?;
5876            Ok(())
5877        }
5878    }
5879
5880    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5881        for TargetHandlerGetNotificationRequest
5882    {
5883        #[inline(always)]
5884        fn new_empty() -> Self {
5885            Self { event_id: fidl::new_empty!(NotificationEvent, D) }
5886        }
5887
5888        #[inline]
5889        unsafe fn decode(
5890            &mut self,
5891            decoder: &mut fidl::encoding::Decoder<'_, D>,
5892            offset: usize,
5893            _depth: fidl::encoding::Depth,
5894        ) -> fidl::Result<()> {
5895            decoder.debug_check_bounds::<Self>(offset);
5896            // Verify that padding bytes are zero.
5897            fidl::decode!(NotificationEvent, D, &mut self.event_id, decoder, offset + 0, _depth)?;
5898            Ok(())
5899        }
5900    }
5901
5902    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayerApplicationSettingsRequest {
5903        type Borrowed<'a> = &'a Self;
5904        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5905            value
5906        }
5907    }
5908
5909    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayerApplicationSettingsRequest {
5910        type Owned = Self;
5911
5912        #[inline(always)]
5913        fn inline_align(_context: fidl::encoding::Context) -> usize {
5914            8
5915        }
5916
5917        #[inline(always)]
5918        fn inline_size(_context: fidl::encoding::Context) -> usize {
5919            16
5920        }
5921    }
5922
5923    unsafe impl<D: fidl::encoding::ResourceDialect>
5924        fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsRequest, D>
5925        for &TargetHandlerGetPlayerApplicationSettingsRequest
5926    {
5927        #[inline]
5928        unsafe fn encode(
5929            self,
5930            encoder: &mut fidl::encoding::Encoder<'_, D>,
5931            offset: usize,
5932            _depth: fidl::encoding::Depth,
5933        ) -> fidl::Result<()> {
5934            encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsRequest>(offset);
5935            // Delegate to tuple encoding.
5936            fidl::encoding::Encode::<TargetHandlerGetPlayerApplicationSettingsRequest, D>::encode(
5937                (
5938                    <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attribute_ids),
5939                ),
5940                encoder, offset, _depth
5941            )
5942        }
5943    }
5944    unsafe impl<
5945            D: fidl::encoding::ResourceDialect,
5946            T0: fidl::encoding::Encode<
5947                fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
5948                D,
5949            >,
5950        > fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsRequest, D> for (T0,)
5951    {
5952        #[inline]
5953        unsafe fn encode(
5954            self,
5955            encoder: &mut fidl::encoding::Encoder<'_, D>,
5956            offset: usize,
5957            depth: fidl::encoding::Depth,
5958        ) -> fidl::Result<()> {
5959            encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsRequest>(offset);
5960            // Zero out padding regions. There's no need to apply masks
5961            // because the unmasked parts will be overwritten by fields.
5962            // Write the fields.
5963            self.0.encode(encoder, offset + 0, depth)?;
5964            Ok(())
5965        }
5966    }
5967
5968    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5969        for TargetHandlerGetPlayerApplicationSettingsRequest
5970    {
5971        #[inline(always)]
5972        fn new_empty() -> Self {
5973            Self {
5974                attribute_ids: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
5975            }
5976        }
5977
5978        #[inline]
5979        unsafe fn decode(
5980            &mut self,
5981            decoder: &mut fidl::encoding::Decoder<'_, D>,
5982            offset: usize,
5983            _depth: fidl::encoding::Depth,
5984        ) -> fidl::Result<()> {
5985            decoder.debug_check_bounds::<Self>(offset);
5986            // Verify that padding bytes are zero.
5987            fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attribute_ids, decoder, offset + 0, _depth)?;
5988            Ok(())
5989        }
5990    }
5991
5992    impl fidl::encoding::ValueTypeMarker for TargetHandlerSendCommandRequest {
5993        type Borrowed<'a> = &'a Self;
5994        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5995            value
5996        }
5997    }
5998
5999    unsafe impl fidl::encoding::TypeMarker for TargetHandlerSendCommandRequest {
6000        type Owned = Self;
6001
6002        #[inline(always)]
6003        fn inline_align(_context: fidl::encoding::Context) -> usize {
6004            1
6005        }
6006
6007        #[inline(always)]
6008        fn inline_size(_context: fidl::encoding::Context) -> usize {
6009            2
6010        }
6011    }
6012
6013    unsafe impl<D: fidl::encoding::ResourceDialect>
6014        fidl::encoding::Encode<TargetHandlerSendCommandRequest, D>
6015        for &TargetHandlerSendCommandRequest
6016    {
6017        #[inline]
6018        unsafe fn encode(
6019            self,
6020            encoder: &mut fidl::encoding::Encoder<'_, D>,
6021            offset: usize,
6022            _depth: fidl::encoding::Depth,
6023        ) -> fidl::Result<()> {
6024            encoder.debug_check_bounds::<TargetHandlerSendCommandRequest>(offset);
6025            // Delegate to tuple encoding.
6026            fidl::encoding::Encode::<TargetHandlerSendCommandRequest, D>::encode(
6027                (
6028                    <AvcPanelCommand as fidl::encoding::ValueTypeMarker>::borrow(&self.command),
6029                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.pressed),
6030                ),
6031                encoder,
6032                offset,
6033                _depth,
6034            )
6035        }
6036    }
6037    unsafe impl<
6038            D: fidl::encoding::ResourceDialect,
6039            T0: fidl::encoding::Encode<AvcPanelCommand, D>,
6040            T1: fidl::encoding::Encode<bool, D>,
6041        > fidl::encoding::Encode<TargetHandlerSendCommandRequest, D> for (T0, T1)
6042    {
6043        #[inline]
6044        unsafe fn encode(
6045            self,
6046            encoder: &mut fidl::encoding::Encoder<'_, D>,
6047            offset: usize,
6048            depth: fidl::encoding::Depth,
6049        ) -> fidl::Result<()> {
6050            encoder.debug_check_bounds::<TargetHandlerSendCommandRequest>(offset);
6051            // Zero out padding regions. There's no need to apply masks
6052            // because the unmasked parts will be overwritten by fields.
6053            // Write the fields.
6054            self.0.encode(encoder, offset + 0, depth)?;
6055            self.1.encode(encoder, offset + 1, depth)?;
6056            Ok(())
6057        }
6058    }
6059
6060    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6061        for TargetHandlerSendCommandRequest
6062    {
6063        #[inline(always)]
6064        fn new_empty() -> Self {
6065            Self {
6066                command: fidl::new_empty!(AvcPanelCommand, D),
6067                pressed: fidl::new_empty!(bool, D),
6068            }
6069        }
6070
6071        #[inline]
6072        unsafe fn decode(
6073            &mut self,
6074            decoder: &mut fidl::encoding::Decoder<'_, D>,
6075            offset: usize,
6076            _depth: fidl::encoding::Depth,
6077        ) -> fidl::Result<()> {
6078            decoder.debug_check_bounds::<Self>(offset);
6079            // Verify that padding bytes are zero.
6080            fidl::decode!(AvcPanelCommand, D, &mut self.command, decoder, offset + 0, _depth)?;
6081            fidl::decode!(bool, D, &mut self.pressed, decoder, offset + 1, _depth)?;
6082            Ok(())
6083        }
6084    }
6085
6086    impl fidl::encoding::ValueTypeMarker for TargetHandlerSetAddressedPlayerRequest {
6087        type Borrowed<'a> = &'a Self;
6088        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6089            value
6090        }
6091    }
6092
6093    unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetAddressedPlayerRequest {
6094        type Owned = Self;
6095
6096        #[inline(always)]
6097        fn inline_align(_context: fidl::encoding::Context) -> usize {
6098            2
6099        }
6100
6101        #[inline(always)]
6102        fn inline_size(_context: fidl::encoding::Context) -> usize {
6103            2
6104        }
6105        #[inline(always)]
6106        fn encode_is_copy() -> bool {
6107            true
6108        }
6109
6110        #[inline(always)]
6111        fn decode_is_copy() -> bool {
6112            true
6113        }
6114    }
6115
6116    unsafe impl<D: fidl::encoding::ResourceDialect>
6117        fidl::encoding::Encode<TargetHandlerSetAddressedPlayerRequest, D>
6118        for &TargetHandlerSetAddressedPlayerRequest
6119    {
6120        #[inline]
6121        unsafe fn encode(
6122            self,
6123            encoder: &mut fidl::encoding::Encoder<'_, D>,
6124            offset: usize,
6125            _depth: fidl::encoding::Depth,
6126        ) -> fidl::Result<()> {
6127            encoder.debug_check_bounds::<TargetHandlerSetAddressedPlayerRequest>(offset);
6128            unsafe {
6129                // Copy the object into the buffer.
6130                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6131                (buf_ptr as *mut TargetHandlerSetAddressedPlayerRequest).write_unaligned(
6132                    (self as *const TargetHandlerSetAddressedPlayerRequest).read(),
6133                );
6134                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
6135                // done second because the memcpy will write garbage to these bytes.
6136            }
6137            Ok(())
6138        }
6139    }
6140    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AddressedPlayerId, D>>
6141        fidl::encoding::Encode<TargetHandlerSetAddressedPlayerRequest, D> for (T0,)
6142    {
6143        #[inline]
6144        unsafe fn encode(
6145            self,
6146            encoder: &mut fidl::encoding::Encoder<'_, D>,
6147            offset: usize,
6148            depth: fidl::encoding::Depth,
6149        ) -> fidl::Result<()> {
6150            encoder.debug_check_bounds::<TargetHandlerSetAddressedPlayerRequest>(offset);
6151            // Zero out padding regions. There's no need to apply masks
6152            // because the unmasked parts will be overwritten by fields.
6153            // Write the fields.
6154            self.0.encode(encoder, offset + 0, depth)?;
6155            Ok(())
6156        }
6157    }
6158
6159    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6160        for TargetHandlerSetAddressedPlayerRequest
6161    {
6162        #[inline(always)]
6163        fn new_empty() -> Self {
6164            Self { player_id: fidl::new_empty!(AddressedPlayerId, D) }
6165        }
6166
6167        #[inline]
6168        unsafe fn decode(
6169            &mut self,
6170            decoder: &mut fidl::encoding::Decoder<'_, D>,
6171            offset: usize,
6172            _depth: fidl::encoding::Depth,
6173        ) -> fidl::Result<()> {
6174            decoder.debug_check_bounds::<Self>(offset);
6175            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6176            // Verify that padding bytes are zero.
6177            // Copy from the buffer into the object.
6178            unsafe {
6179                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
6180            }
6181            Ok(())
6182        }
6183    }
6184
6185    impl fidl::encoding::ValueTypeMarker for TargetHandlerSetPlayerApplicationSettingsRequest {
6186        type Borrowed<'a> = &'a Self;
6187        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6188            value
6189        }
6190    }
6191
6192    unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetPlayerApplicationSettingsRequest {
6193        type Owned = Self;
6194
6195        #[inline(always)]
6196        fn inline_align(_context: fidl::encoding::Context) -> usize {
6197            8
6198        }
6199
6200        #[inline(always)]
6201        fn inline_size(_context: fidl::encoding::Context) -> usize {
6202            16
6203        }
6204    }
6205
6206    unsafe impl<D: fidl::encoding::ResourceDialect>
6207        fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsRequest, D>
6208        for &TargetHandlerSetPlayerApplicationSettingsRequest
6209    {
6210        #[inline]
6211        unsafe fn encode(
6212            self,
6213            encoder: &mut fidl::encoding::Encoder<'_, D>,
6214            offset: usize,
6215            _depth: fidl::encoding::Depth,
6216        ) -> fidl::Result<()> {
6217            encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsRequest>(offset);
6218            // Delegate to tuple encoding.
6219            fidl::encoding::Encode::<TargetHandlerSetPlayerApplicationSettingsRequest, D>::encode(
6220                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
6221                    &self.requested_settings,
6222                ),),
6223                encoder,
6224                offset,
6225                _depth,
6226            )
6227        }
6228    }
6229    unsafe impl<
6230            D: fidl::encoding::ResourceDialect,
6231            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
6232        > fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsRequest, D> for (T0,)
6233    {
6234        #[inline]
6235        unsafe fn encode(
6236            self,
6237            encoder: &mut fidl::encoding::Encoder<'_, D>,
6238            offset: usize,
6239            depth: fidl::encoding::Depth,
6240        ) -> fidl::Result<()> {
6241            encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsRequest>(offset);
6242            // Zero out padding regions. There's no need to apply masks
6243            // because the unmasked parts will be overwritten by fields.
6244            // Write the fields.
6245            self.0.encode(encoder, offset + 0, depth)?;
6246            Ok(())
6247        }
6248    }
6249
6250    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6251        for TargetHandlerSetPlayerApplicationSettingsRequest
6252    {
6253        #[inline(always)]
6254        fn new_empty() -> Self {
6255            Self { requested_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
6256        }
6257
6258        #[inline]
6259        unsafe fn decode(
6260            &mut self,
6261            decoder: &mut fidl::encoding::Decoder<'_, D>,
6262            offset: usize,
6263            _depth: fidl::encoding::Depth,
6264        ) -> fidl::Result<()> {
6265            decoder.debug_check_bounds::<Self>(offset);
6266            // Verify that padding bytes are zero.
6267            fidl::decode!(
6268                PlayerApplicationSettings,
6269                D,
6270                &mut self.requested_settings,
6271                decoder,
6272                offset + 0,
6273                _depth
6274            )?;
6275            Ok(())
6276        }
6277    }
6278
6279    impl fidl::encoding::ValueTypeMarker for TargetHandlerWatchNotificationRequest {
6280        type Borrowed<'a> = &'a Self;
6281        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6282            value
6283        }
6284    }
6285
6286    unsafe impl fidl::encoding::TypeMarker for TargetHandlerWatchNotificationRequest {
6287        type Owned = Self;
6288
6289        #[inline(always)]
6290        fn inline_align(_context: fidl::encoding::Context) -> usize {
6291            8
6292        }
6293
6294        #[inline(always)]
6295        fn inline_size(_context: fidl::encoding::Context) -> usize {
6296            32
6297        }
6298    }
6299
6300    unsafe impl<D: fidl::encoding::ResourceDialect>
6301        fidl::encoding::Encode<TargetHandlerWatchNotificationRequest, D>
6302        for &TargetHandlerWatchNotificationRequest
6303    {
6304        #[inline]
6305        unsafe fn encode(
6306            self,
6307            encoder: &mut fidl::encoding::Encoder<'_, D>,
6308            offset: usize,
6309            _depth: fidl::encoding::Depth,
6310        ) -> fidl::Result<()> {
6311            encoder.debug_check_bounds::<TargetHandlerWatchNotificationRequest>(offset);
6312            // Delegate to tuple encoding.
6313            fidl::encoding::Encode::<TargetHandlerWatchNotificationRequest, D>::encode(
6314                (
6315                    <NotificationEvent as fidl::encoding::ValueTypeMarker>::borrow(&self.event_id),
6316                    <Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.current),
6317                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pos_change_interval),
6318                ),
6319                encoder,
6320                offset,
6321                _depth,
6322            )
6323        }
6324    }
6325    unsafe impl<
6326            D: fidl::encoding::ResourceDialect,
6327            T0: fidl::encoding::Encode<NotificationEvent, D>,
6328            T1: fidl::encoding::Encode<Notification, D>,
6329            T2: fidl::encoding::Encode<u32, D>,
6330        > fidl::encoding::Encode<TargetHandlerWatchNotificationRequest, D> for (T0, T1, T2)
6331    {
6332        #[inline]
6333        unsafe fn encode(
6334            self,
6335            encoder: &mut fidl::encoding::Encoder<'_, D>,
6336            offset: usize,
6337            depth: fidl::encoding::Depth,
6338        ) -> fidl::Result<()> {
6339            encoder.debug_check_bounds::<TargetHandlerWatchNotificationRequest>(offset);
6340            // Zero out padding regions. There's no need to apply masks
6341            // because the unmasked parts will be overwritten by fields.
6342            unsafe {
6343                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6344                (ptr as *mut u64).write_unaligned(0);
6345            }
6346            unsafe {
6347                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
6348                (ptr as *mut u64).write_unaligned(0);
6349            }
6350            // Write the fields.
6351            self.0.encode(encoder, offset + 0, depth)?;
6352            self.1.encode(encoder, offset + 8, depth)?;
6353            self.2.encode(encoder, offset + 24, depth)?;
6354            Ok(())
6355        }
6356    }
6357
6358    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6359        for TargetHandlerWatchNotificationRequest
6360    {
6361        #[inline(always)]
6362        fn new_empty() -> Self {
6363            Self {
6364                event_id: fidl::new_empty!(NotificationEvent, D),
6365                current: fidl::new_empty!(Notification, D),
6366                pos_change_interval: fidl::new_empty!(u32, D),
6367            }
6368        }
6369
6370        #[inline]
6371        unsafe fn decode(
6372            &mut self,
6373            decoder: &mut fidl::encoding::Decoder<'_, D>,
6374            offset: usize,
6375            _depth: fidl::encoding::Depth,
6376        ) -> fidl::Result<()> {
6377            decoder.debug_check_bounds::<Self>(offset);
6378            // Verify that padding bytes are zero.
6379            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
6380            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6381            let mask = 0xffffffffffffff00u64;
6382            let maskedval = padval & mask;
6383            if maskedval != 0 {
6384                return Err(fidl::Error::NonZeroPadding {
6385                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
6386                });
6387            }
6388            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
6389            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6390            let mask = 0xffffffff00000000u64;
6391            let maskedval = padval & mask;
6392            if maskedval != 0 {
6393                return Err(fidl::Error::NonZeroPadding {
6394                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
6395                });
6396            }
6397            fidl::decode!(NotificationEvent, D, &mut self.event_id, decoder, offset + 0, _depth)?;
6398            fidl::decode!(Notification, D, &mut self.current, decoder, offset + 8, _depth)?;
6399            fidl::decode!(u32, D, &mut self.pos_change_interval, decoder, offset + 24, _depth)?;
6400            Ok(())
6401        }
6402    }
6403
6404    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetEventsSupportedResponse {
6405        type Borrowed<'a> = &'a Self;
6406        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6407            value
6408        }
6409    }
6410
6411    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetEventsSupportedResponse {
6412        type Owned = Self;
6413
6414        #[inline(always)]
6415        fn inline_align(_context: fidl::encoding::Context) -> usize {
6416            8
6417        }
6418
6419        #[inline(always)]
6420        fn inline_size(_context: fidl::encoding::Context) -> usize {
6421            16
6422        }
6423    }
6424
6425    unsafe impl<D: fidl::encoding::ResourceDialect>
6426        fidl::encoding::Encode<TargetHandlerGetEventsSupportedResponse, D>
6427        for &TargetHandlerGetEventsSupportedResponse
6428    {
6429        #[inline]
6430        unsafe fn encode(
6431            self,
6432            encoder: &mut fidl::encoding::Encoder<'_, D>,
6433            offset: usize,
6434            _depth: fidl::encoding::Depth,
6435        ) -> fidl::Result<()> {
6436            encoder.debug_check_bounds::<TargetHandlerGetEventsSupportedResponse>(offset);
6437            // Delegate to tuple encoding.
6438            fidl::encoding::Encode::<TargetHandlerGetEventsSupportedResponse, D>::encode(
6439                (
6440                    <fidl::encoding::Vector<NotificationEvent, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.notification_ids),
6441                ),
6442                encoder, offset, _depth
6443            )
6444        }
6445    }
6446    unsafe impl<
6447            D: fidl::encoding::ResourceDialect,
6448            T0: fidl::encoding::Encode<fidl::encoding::Vector<NotificationEvent, 255>, D>,
6449        > fidl::encoding::Encode<TargetHandlerGetEventsSupportedResponse, D> for (T0,)
6450    {
6451        #[inline]
6452        unsafe fn encode(
6453            self,
6454            encoder: &mut fidl::encoding::Encoder<'_, D>,
6455            offset: usize,
6456            depth: fidl::encoding::Depth,
6457        ) -> fidl::Result<()> {
6458            encoder.debug_check_bounds::<TargetHandlerGetEventsSupportedResponse>(offset);
6459            // Zero out padding regions. There's no need to apply masks
6460            // because the unmasked parts will be overwritten by fields.
6461            // Write the fields.
6462            self.0.encode(encoder, offset + 0, depth)?;
6463            Ok(())
6464        }
6465    }
6466
6467    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6468        for TargetHandlerGetEventsSupportedResponse
6469    {
6470        #[inline(always)]
6471        fn new_empty() -> Self {
6472            Self {
6473                notification_ids: fidl::new_empty!(fidl::encoding::Vector<NotificationEvent, 255>, D),
6474            }
6475        }
6476
6477        #[inline]
6478        unsafe fn decode(
6479            &mut self,
6480            decoder: &mut fidl::encoding::Decoder<'_, D>,
6481            offset: usize,
6482            _depth: fidl::encoding::Depth,
6483        ) -> fidl::Result<()> {
6484            decoder.debug_check_bounds::<Self>(offset);
6485            // Verify that padding bytes are zero.
6486            fidl::decode!(fidl::encoding::Vector<NotificationEvent, 255>, D, &mut self.notification_ids, decoder, offset + 0, _depth)?;
6487            Ok(())
6488        }
6489    }
6490
6491    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetMediaAttributesResponse {
6492        type Borrowed<'a> = &'a Self;
6493        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6494            value
6495        }
6496    }
6497
6498    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetMediaAttributesResponse {
6499        type Owned = Self;
6500
6501        #[inline(always)]
6502        fn inline_align(_context: fidl::encoding::Context) -> usize {
6503            8
6504        }
6505
6506        #[inline(always)]
6507        fn inline_size(_context: fidl::encoding::Context) -> usize {
6508            16
6509        }
6510    }
6511
6512    unsafe impl<D: fidl::encoding::ResourceDialect>
6513        fidl::encoding::Encode<TargetHandlerGetMediaAttributesResponse, D>
6514        for &TargetHandlerGetMediaAttributesResponse
6515    {
6516        #[inline]
6517        unsafe fn encode(
6518            self,
6519            encoder: &mut fidl::encoding::Encoder<'_, D>,
6520            offset: usize,
6521            _depth: fidl::encoding::Depth,
6522        ) -> fidl::Result<()> {
6523            encoder.debug_check_bounds::<TargetHandlerGetMediaAttributesResponse>(offset);
6524            // Delegate to tuple encoding.
6525            fidl::encoding::Encode::<TargetHandlerGetMediaAttributesResponse, D>::encode(
6526                (<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),),
6527                encoder,
6528                offset,
6529                _depth,
6530            )
6531        }
6532    }
6533    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MediaAttributes, D>>
6534        fidl::encoding::Encode<TargetHandlerGetMediaAttributesResponse, D> for (T0,)
6535    {
6536        #[inline]
6537        unsafe fn encode(
6538            self,
6539            encoder: &mut fidl::encoding::Encoder<'_, D>,
6540            offset: usize,
6541            depth: fidl::encoding::Depth,
6542        ) -> fidl::Result<()> {
6543            encoder.debug_check_bounds::<TargetHandlerGetMediaAttributesResponse>(offset);
6544            // Zero out padding regions. There's no need to apply masks
6545            // because the unmasked parts will be overwritten by fields.
6546            // Write the fields.
6547            self.0.encode(encoder, offset + 0, depth)?;
6548            Ok(())
6549        }
6550    }
6551
6552    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6553        for TargetHandlerGetMediaAttributesResponse
6554    {
6555        #[inline(always)]
6556        fn new_empty() -> Self {
6557            Self { attributes: fidl::new_empty!(MediaAttributes, D) }
6558        }
6559
6560        #[inline]
6561        unsafe fn decode(
6562            &mut self,
6563            decoder: &mut fidl::encoding::Decoder<'_, D>,
6564            offset: usize,
6565            _depth: fidl::encoding::Depth,
6566        ) -> fidl::Result<()> {
6567            decoder.debug_check_bounds::<Self>(offset);
6568            // Verify that padding bytes are zero.
6569            fidl::decode!(MediaAttributes, D, &mut self.attributes, decoder, offset + 0, _depth)?;
6570            Ok(())
6571        }
6572    }
6573
6574    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetMediaPlayerItemsResponse {
6575        type Borrowed<'a> = &'a Self;
6576        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6577            value
6578        }
6579    }
6580
6581    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetMediaPlayerItemsResponse {
6582        type Owned = Self;
6583
6584        #[inline(always)]
6585        fn inline_align(_context: fidl::encoding::Context) -> usize {
6586            8
6587        }
6588
6589        #[inline(always)]
6590        fn inline_size(_context: fidl::encoding::Context) -> usize {
6591            16
6592        }
6593    }
6594
6595    unsafe impl<D: fidl::encoding::ResourceDialect>
6596        fidl::encoding::Encode<TargetHandlerGetMediaPlayerItemsResponse, D>
6597        for &TargetHandlerGetMediaPlayerItemsResponse
6598    {
6599        #[inline]
6600        unsafe fn encode(
6601            self,
6602            encoder: &mut fidl::encoding::Encoder<'_, D>,
6603            offset: usize,
6604            _depth: fidl::encoding::Depth,
6605        ) -> fidl::Result<()> {
6606            encoder.debug_check_bounds::<TargetHandlerGetMediaPlayerItemsResponse>(offset);
6607            // Delegate to tuple encoding.
6608            fidl::encoding::Encode::<TargetHandlerGetMediaPlayerItemsResponse, D>::encode(
6609                (
6610                    <fidl::encoding::Vector<MediaPlayerItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
6611                ),
6612                encoder, offset, _depth
6613            )
6614        }
6615    }
6616    unsafe impl<
6617            D: fidl::encoding::ResourceDialect,
6618            T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaPlayerItem, 16>, D>,
6619        > fidl::encoding::Encode<TargetHandlerGetMediaPlayerItemsResponse, D> for (T0,)
6620    {
6621        #[inline]
6622        unsafe fn encode(
6623            self,
6624            encoder: &mut fidl::encoding::Encoder<'_, D>,
6625            offset: usize,
6626            depth: fidl::encoding::Depth,
6627        ) -> fidl::Result<()> {
6628            encoder.debug_check_bounds::<TargetHandlerGetMediaPlayerItemsResponse>(offset);
6629            // Zero out padding regions. There's no need to apply masks
6630            // because the unmasked parts will be overwritten by fields.
6631            // Write the fields.
6632            self.0.encode(encoder, offset + 0, depth)?;
6633            Ok(())
6634        }
6635    }
6636
6637    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6638        for TargetHandlerGetMediaPlayerItemsResponse
6639    {
6640        #[inline(always)]
6641        fn new_empty() -> Self {
6642            Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaPlayerItem, 16>, D) }
6643        }
6644
6645        #[inline]
6646        unsafe fn decode(
6647            &mut self,
6648            decoder: &mut fidl::encoding::Decoder<'_, D>,
6649            offset: usize,
6650            _depth: fidl::encoding::Depth,
6651        ) -> fidl::Result<()> {
6652            decoder.debug_check_bounds::<Self>(offset);
6653            // Verify that padding bytes are zero.
6654            fidl::decode!(fidl::encoding::Vector<MediaPlayerItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
6655            Ok(())
6656        }
6657    }
6658
6659    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetNotificationResponse {
6660        type Borrowed<'a> = &'a Self;
6661        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6662            value
6663        }
6664    }
6665
6666    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetNotificationResponse {
6667        type Owned = Self;
6668
6669        #[inline(always)]
6670        fn inline_align(_context: fidl::encoding::Context) -> usize {
6671            8
6672        }
6673
6674        #[inline(always)]
6675        fn inline_size(_context: fidl::encoding::Context) -> usize {
6676            16
6677        }
6678    }
6679
6680    unsafe impl<D: fidl::encoding::ResourceDialect>
6681        fidl::encoding::Encode<TargetHandlerGetNotificationResponse, D>
6682        for &TargetHandlerGetNotificationResponse
6683    {
6684        #[inline]
6685        unsafe fn encode(
6686            self,
6687            encoder: &mut fidl::encoding::Encoder<'_, D>,
6688            offset: usize,
6689            _depth: fidl::encoding::Depth,
6690        ) -> fidl::Result<()> {
6691            encoder.debug_check_bounds::<TargetHandlerGetNotificationResponse>(offset);
6692            // Delegate to tuple encoding.
6693            fidl::encoding::Encode::<TargetHandlerGetNotificationResponse, D>::encode(
6694                (<Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.current_value),),
6695                encoder,
6696                offset,
6697                _depth,
6698            )
6699        }
6700    }
6701    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Notification, D>>
6702        fidl::encoding::Encode<TargetHandlerGetNotificationResponse, D> for (T0,)
6703    {
6704        #[inline]
6705        unsafe fn encode(
6706            self,
6707            encoder: &mut fidl::encoding::Encoder<'_, D>,
6708            offset: usize,
6709            depth: fidl::encoding::Depth,
6710        ) -> fidl::Result<()> {
6711            encoder.debug_check_bounds::<TargetHandlerGetNotificationResponse>(offset);
6712            // Zero out padding regions. There's no need to apply masks
6713            // because the unmasked parts will be overwritten by fields.
6714            // Write the fields.
6715            self.0.encode(encoder, offset + 0, depth)?;
6716            Ok(())
6717        }
6718    }
6719
6720    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6721        for TargetHandlerGetNotificationResponse
6722    {
6723        #[inline(always)]
6724        fn new_empty() -> Self {
6725            Self { current_value: fidl::new_empty!(Notification, D) }
6726        }
6727
6728        #[inline]
6729        unsafe fn decode(
6730            &mut self,
6731            decoder: &mut fidl::encoding::Decoder<'_, D>,
6732            offset: usize,
6733            _depth: fidl::encoding::Depth,
6734        ) -> fidl::Result<()> {
6735            decoder.debug_check_bounds::<Self>(offset);
6736            // Verify that padding bytes are zero.
6737            fidl::decode!(Notification, D, &mut self.current_value, decoder, offset + 0, _depth)?;
6738            Ok(())
6739        }
6740    }
6741
6742    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayStatusResponse {
6743        type Borrowed<'a> = &'a Self;
6744        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6745            value
6746        }
6747    }
6748
6749    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayStatusResponse {
6750        type Owned = Self;
6751
6752        #[inline(always)]
6753        fn inline_align(_context: fidl::encoding::Context) -> usize {
6754            8
6755        }
6756
6757        #[inline(always)]
6758        fn inline_size(_context: fidl::encoding::Context) -> usize {
6759            16
6760        }
6761    }
6762
6763    unsafe impl<D: fidl::encoding::ResourceDialect>
6764        fidl::encoding::Encode<TargetHandlerGetPlayStatusResponse, D>
6765        for &TargetHandlerGetPlayStatusResponse
6766    {
6767        #[inline]
6768        unsafe fn encode(
6769            self,
6770            encoder: &mut fidl::encoding::Encoder<'_, D>,
6771            offset: usize,
6772            _depth: fidl::encoding::Depth,
6773        ) -> fidl::Result<()> {
6774            encoder.debug_check_bounds::<TargetHandlerGetPlayStatusResponse>(offset);
6775            // Delegate to tuple encoding.
6776            fidl::encoding::Encode::<TargetHandlerGetPlayStatusResponse, D>::encode(
6777                (<PlayStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.play_status),),
6778                encoder,
6779                offset,
6780                _depth,
6781            )
6782        }
6783    }
6784    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PlayStatus, D>>
6785        fidl::encoding::Encode<TargetHandlerGetPlayStatusResponse, D> for (T0,)
6786    {
6787        #[inline]
6788        unsafe fn encode(
6789            self,
6790            encoder: &mut fidl::encoding::Encoder<'_, D>,
6791            offset: usize,
6792            depth: fidl::encoding::Depth,
6793        ) -> fidl::Result<()> {
6794            encoder.debug_check_bounds::<TargetHandlerGetPlayStatusResponse>(offset);
6795            // Zero out padding regions. There's no need to apply masks
6796            // because the unmasked parts will be overwritten by fields.
6797            // Write the fields.
6798            self.0.encode(encoder, offset + 0, depth)?;
6799            Ok(())
6800        }
6801    }
6802
6803    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6804        for TargetHandlerGetPlayStatusResponse
6805    {
6806        #[inline(always)]
6807        fn new_empty() -> Self {
6808            Self { play_status: fidl::new_empty!(PlayStatus, D) }
6809        }
6810
6811        #[inline]
6812        unsafe fn decode(
6813            &mut self,
6814            decoder: &mut fidl::encoding::Decoder<'_, D>,
6815            offset: usize,
6816            _depth: fidl::encoding::Depth,
6817        ) -> fidl::Result<()> {
6818            decoder.debug_check_bounds::<Self>(offset);
6819            // Verify that padding bytes are zero.
6820            fidl::decode!(PlayStatus, D, &mut self.play_status, decoder, offset + 0, _depth)?;
6821            Ok(())
6822        }
6823    }
6824
6825    impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayerApplicationSettingsResponse {
6826        type Borrowed<'a> = &'a Self;
6827        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6828            value
6829        }
6830    }
6831
6832    unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayerApplicationSettingsResponse {
6833        type Owned = Self;
6834
6835        #[inline(always)]
6836        fn inline_align(_context: fidl::encoding::Context) -> usize {
6837            8
6838        }
6839
6840        #[inline(always)]
6841        fn inline_size(_context: fidl::encoding::Context) -> usize {
6842            16
6843        }
6844    }
6845
6846    unsafe impl<D: fidl::encoding::ResourceDialect>
6847        fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsResponse, D>
6848        for &TargetHandlerGetPlayerApplicationSettingsResponse
6849    {
6850        #[inline]
6851        unsafe fn encode(
6852            self,
6853            encoder: &mut fidl::encoding::Encoder<'_, D>,
6854            offset: usize,
6855            _depth: fidl::encoding::Depth,
6856        ) -> fidl::Result<()> {
6857            encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsResponse>(offset);
6858            // Delegate to tuple encoding.
6859            fidl::encoding::Encode::<TargetHandlerGetPlayerApplicationSettingsResponse, D>::encode(
6860                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
6861                    &self.current_settings,
6862                ),),
6863                encoder,
6864                offset,
6865                _depth,
6866            )
6867        }
6868    }
6869    unsafe impl<
6870            D: fidl::encoding::ResourceDialect,
6871            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
6872        > fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsResponse, D> for (T0,)
6873    {
6874        #[inline]
6875        unsafe fn encode(
6876            self,
6877            encoder: &mut fidl::encoding::Encoder<'_, D>,
6878            offset: usize,
6879            depth: fidl::encoding::Depth,
6880        ) -> fidl::Result<()> {
6881            encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsResponse>(offset);
6882            // Zero out padding regions. There's no need to apply masks
6883            // because the unmasked parts will be overwritten by fields.
6884            // Write the fields.
6885            self.0.encode(encoder, offset + 0, depth)?;
6886            Ok(())
6887        }
6888    }
6889
6890    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6891        for TargetHandlerGetPlayerApplicationSettingsResponse
6892    {
6893        #[inline(always)]
6894        fn new_empty() -> Self {
6895            Self { current_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
6896        }
6897
6898        #[inline]
6899        unsafe fn decode(
6900            &mut self,
6901            decoder: &mut fidl::encoding::Decoder<'_, D>,
6902            offset: usize,
6903            _depth: fidl::encoding::Depth,
6904        ) -> fidl::Result<()> {
6905            decoder.debug_check_bounds::<Self>(offset);
6906            // Verify that padding bytes are zero.
6907            fidl::decode!(
6908                PlayerApplicationSettings,
6909                D,
6910                &mut self.current_settings,
6911                decoder,
6912                offset + 0,
6913                _depth
6914            )?;
6915            Ok(())
6916        }
6917    }
6918
6919    impl fidl::encoding::ValueTypeMarker
6920        for TargetHandlerListPlayerApplicationSettingAttributesResponse
6921    {
6922        type Borrowed<'a> = &'a Self;
6923        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6924            value
6925        }
6926    }
6927
6928    unsafe impl fidl::encoding::TypeMarker
6929        for TargetHandlerListPlayerApplicationSettingAttributesResponse
6930    {
6931        type Owned = Self;
6932
6933        #[inline(always)]
6934        fn inline_align(_context: fidl::encoding::Context) -> usize {
6935            8
6936        }
6937
6938        #[inline(always)]
6939        fn inline_size(_context: fidl::encoding::Context) -> usize {
6940            16
6941        }
6942    }
6943
6944    unsafe impl<D: fidl::encoding::ResourceDialect>
6945        fidl::encoding::Encode<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>
6946        for &TargetHandlerListPlayerApplicationSettingAttributesResponse
6947    {
6948        #[inline]
6949        unsafe fn encode(
6950            self,
6951            encoder: &mut fidl::encoding::Encoder<'_, D>,
6952            offset: usize,
6953            _depth: fidl::encoding::Depth,
6954        ) -> fidl::Result<()> {
6955            encoder
6956                .debug_check_bounds::<TargetHandlerListPlayerApplicationSettingAttributesResponse>(
6957                    offset,
6958                );
6959            // Delegate to tuple encoding.
6960            fidl::encoding::Encode::<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>::encode(
6961                (
6962                    <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
6963                ),
6964                encoder, offset, _depth
6965            )
6966        }
6967    }
6968    unsafe impl<
6969            D: fidl::encoding::ResourceDialect,
6970            T0: fidl::encoding::Encode<
6971                fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
6972                D,
6973            >,
6974        > fidl::encoding::Encode<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>
6975        for (T0,)
6976    {
6977        #[inline]
6978        unsafe fn encode(
6979            self,
6980            encoder: &mut fidl::encoding::Encoder<'_, D>,
6981            offset: usize,
6982            depth: fidl::encoding::Depth,
6983        ) -> fidl::Result<()> {
6984            encoder
6985                .debug_check_bounds::<TargetHandlerListPlayerApplicationSettingAttributesResponse>(
6986                    offset,
6987                );
6988            // Zero out padding regions. There's no need to apply masks
6989            // because the unmasked parts will be overwritten by fields.
6990            // Write the fields.
6991            self.0.encode(encoder, offset + 0, depth)?;
6992            Ok(())
6993        }
6994    }
6995
6996    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6997        for TargetHandlerListPlayerApplicationSettingAttributesResponse
6998    {
6999        #[inline(always)]
7000        fn new_empty() -> Self {
7001            Self {
7002                attributes: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
7003            }
7004        }
7005
7006        #[inline]
7007        unsafe fn decode(
7008            &mut self,
7009            decoder: &mut fidl::encoding::Decoder<'_, D>,
7010            offset: usize,
7011            _depth: fidl::encoding::Depth,
7012        ) -> fidl::Result<()> {
7013            decoder.debug_check_bounds::<Self>(offset);
7014            // Verify that padding bytes are zero.
7015            fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attributes, decoder, offset + 0, _depth)?;
7016            Ok(())
7017        }
7018    }
7019
7020    impl fidl::encoding::ValueTypeMarker for TargetHandlerSetPlayerApplicationSettingsResponse {
7021        type Borrowed<'a> = &'a Self;
7022        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7023            value
7024        }
7025    }
7026
7027    unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetPlayerApplicationSettingsResponse {
7028        type Owned = Self;
7029
7030        #[inline(always)]
7031        fn inline_align(_context: fidl::encoding::Context) -> usize {
7032            8
7033        }
7034
7035        #[inline(always)]
7036        fn inline_size(_context: fidl::encoding::Context) -> usize {
7037            16
7038        }
7039    }
7040
7041    unsafe impl<D: fidl::encoding::ResourceDialect>
7042        fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsResponse, D>
7043        for &TargetHandlerSetPlayerApplicationSettingsResponse
7044    {
7045        #[inline]
7046        unsafe fn encode(
7047            self,
7048            encoder: &mut fidl::encoding::Encoder<'_, D>,
7049            offset: usize,
7050            _depth: fidl::encoding::Depth,
7051        ) -> fidl::Result<()> {
7052            encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsResponse>(offset);
7053            // Delegate to tuple encoding.
7054            fidl::encoding::Encode::<TargetHandlerSetPlayerApplicationSettingsResponse, D>::encode(
7055                (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
7056                    &self.set_settings,
7057                ),),
7058                encoder,
7059                offset,
7060                _depth,
7061            )
7062        }
7063    }
7064    unsafe impl<
7065            D: fidl::encoding::ResourceDialect,
7066            T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
7067        > fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsResponse, D> for (T0,)
7068    {
7069        #[inline]
7070        unsafe fn encode(
7071            self,
7072            encoder: &mut fidl::encoding::Encoder<'_, D>,
7073            offset: usize,
7074            depth: fidl::encoding::Depth,
7075        ) -> fidl::Result<()> {
7076            encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsResponse>(offset);
7077            // Zero out padding regions. There's no need to apply masks
7078            // because the unmasked parts will be overwritten by fields.
7079            // Write the fields.
7080            self.0.encode(encoder, offset + 0, depth)?;
7081            Ok(())
7082        }
7083    }
7084
7085    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7086        for TargetHandlerSetPlayerApplicationSettingsResponse
7087    {
7088        #[inline(always)]
7089        fn new_empty() -> Self {
7090            Self { set_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
7091        }
7092
7093        #[inline]
7094        unsafe fn decode(
7095            &mut self,
7096            decoder: &mut fidl::encoding::Decoder<'_, D>,
7097            offset: usize,
7098            _depth: fidl::encoding::Depth,
7099        ) -> fidl::Result<()> {
7100            decoder.debug_check_bounds::<Self>(offset);
7101            // Verify that padding bytes are zero.
7102            fidl::decode!(
7103                PlayerApplicationSettings,
7104                D,
7105                &mut self.set_settings,
7106                decoder,
7107                offset + 0,
7108                _depth
7109            )?;
7110            Ok(())
7111        }
7112    }
7113
7114    impl fidl::encoding::ValueTypeMarker for TargetHandlerWatchNotificationResponse {
7115        type Borrowed<'a> = &'a Self;
7116        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7117            value
7118        }
7119    }
7120
7121    unsafe impl fidl::encoding::TypeMarker for TargetHandlerWatchNotificationResponse {
7122        type Owned = Self;
7123
7124        #[inline(always)]
7125        fn inline_align(_context: fidl::encoding::Context) -> usize {
7126            8
7127        }
7128
7129        #[inline(always)]
7130        fn inline_size(_context: fidl::encoding::Context) -> usize {
7131            16
7132        }
7133    }
7134
7135    unsafe impl<D: fidl::encoding::ResourceDialect>
7136        fidl::encoding::Encode<TargetHandlerWatchNotificationResponse, D>
7137        for &TargetHandlerWatchNotificationResponse
7138    {
7139        #[inline]
7140        unsafe fn encode(
7141            self,
7142            encoder: &mut fidl::encoding::Encoder<'_, D>,
7143            offset: usize,
7144            _depth: fidl::encoding::Depth,
7145        ) -> fidl::Result<()> {
7146            encoder.debug_check_bounds::<TargetHandlerWatchNotificationResponse>(offset);
7147            // Delegate to tuple encoding.
7148            fidl::encoding::Encode::<TargetHandlerWatchNotificationResponse, D>::encode(
7149                (<Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.new_value),),
7150                encoder,
7151                offset,
7152                _depth,
7153            )
7154        }
7155    }
7156    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Notification, D>>
7157        fidl::encoding::Encode<TargetHandlerWatchNotificationResponse, D> for (T0,)
7158    {
7159        #[inline]
7160        unsafe fn encode(
7161            self,
7162            encoder: &mut fidl::encoding::Encoder<'_, D>,
7163            offset: usize,
7164            depth: fidl::encoding::Depth,
7165        ) -> fidl::Result<()> {
7166            encoder.debug_check_bounds::<TargetHandlerWatchNotificationResponse>(offset);
7167            // Zero out padding regions. There's no need to apply masks
7168            // because the unmasked parts will be overwritten by fields.
7169            // Write the fields.
7170            self.0.encode(encoder, offset + 0, depth)?;
7171            Ok(())
7172        }
7173    }
7174
7175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7176        for TargetHandlerWatchNotificationResponse
7177    {
7178        #[inline(always)]
7179        fn new_empty() -> Self {
7180            Self { new_value: fidl::new_empty!(Notification, D) }
7181        }
7182
7183        #[inline]
7184        unsafe fn decode(
7185            &mut self,
7186            decoder: &mut fidl::encoding::Decoder<'_, D>,
7187            offset: usize,
7188            _depth: fidl::encoding::Depth,
7189        ) -> fidl::Result<()> {
7190            decoder.debug_check_bounds::<Self>(offset);
7191            // Verify that padding bytes are zero.
7192            fidl::decode!(Notification, D, &mut self.new_value, decoder, offset + 0, _depth)?;
7193            Ok(())
7194        }
7195    }
7196
7197    impl CustomPlayerApplicationSetting {
7198        #[inline(always)]
7199        fn max_ordinal_present(&self) -> u64 {
7200            if let Some(_) = self.current_value {
7201                return 4;
7202            }
7203            if let Some(_) = self.possible_values {
7204                return 3;
7205            }
7206            if let Some(_) = self.attribute_name {
7207                return 2;
7208            }
7209            if let Some(_) = self.attribute_id {
7210                return 1;
7211            }
7212            0
7213        }
7214    }
7215
7216    impl fidl::encoding::ValueTypeMarker for CustomPlayerApplicationSetting {
7217        type Borrowed<'a> = &'a Self;
7218        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7219            value
7220        }
7221    }
7222
7223    unsafe impl fidl::encoding::TypeMarker for CustomPlayerApplicationSetting {
7224        type Owned = Self;
7225
7226        #[inline(always)]
7227        fn inline_align(_context: fidl::encoding::Context) -> usize {
7228            8
7229        }
7230
7231        #[inline(always)]
7232        fn inline_size(_context: fidl::encoding::Context) -> usize {
7233            16
7234        }
7235    }
7236
7237    unsafe impl<D: fidl::encoding::ResourceDialect>
7238        fidl::encoding::Encode<CustomPlayerApplicationSetting, D>
7239        for &CustomPlayerApplicationSetting
7240    {
7241        unsafe fn encode(
7242            self,
7243            encoder: &mut fidl::encoding::Encoder<'_, D>,
7244            offset: usize,
7245            mut depth: fidl::encoding::Depth,
7246        ) -> fidl::Result<()> {
7247            encoder.debug_check_bounds::<CustomPlayerApplicationSetting>(offset);
7248            // Vector header
7249            let max_ordinal: u64 = self.max_ordinal_present();
7250            encoder.write_num(max_ordinal, offset);
7251            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7252            // Calling encoder.out_of_line_offset(0) is not allowed.
7253            if max_ordinal == 0 {
7254                return Ok(());
7255            }
7256            depth.increment()?;
7257            let envelope_size = 8;
7258            let bytes_len = max_ordinal as usize * envelope_size;
7259            #[allow(unused_variables)]
7260            let offset = encoder.out_of_line_offset(bytes_len);
7261            let mut _prev_end_offset: usize = 0;
7262            if 1 > max_ordinal {
7263                return Ok(());
7264            }
7265
7266            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7267            // are envelope_size bytes.
7268            let cur_offset: usize = (1 - 1) * envelope_size;
7269
7270            // Zero reserved fields.
7271            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7272
7273            // Safety:
7274            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7275            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7276            //   envelope_size bytes, there is always sufficient room.
7277            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7278                self.attribute_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7279                encoder,
7280                offset + cur_offset,
7281                depth,
7282            )?;
7283
7284            _prev_end_offset = cur_offset + envelope_size;
7285            if 2 > max_ordinal {
7286                return Ok(());
7287            }
7288
7289            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7290            // are envelope_size bytes.
7291            let cur_offset: usize = (2 - 1) * envelope_size;
7292
7293            // Zero reserved fields.
7294            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7295
7296            // Safety:
7297            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7298            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7299            //   envelope_size bytes, there is always sufficient room.
7300            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7301                self.attribute_name.as_ref().map(
7302                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7303                ),
7304                encoder,
7305                offset + cur_offset,
7306                depth,
7307            )?;
7308
7309            _prev_end_offset = cur_offset + envelope_size;
7310            if 3 > max_ordinal {
7311                return Ok(());
7312            }
7313
7314            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7315            // are envelope_size bytes.
7316            let cur_offset: usize = (3 - 1) * envelope_size;
7317
7318            // Zero reserved fields.
7319            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7320
7321            // Safety:
7322            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7323            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7324            //   envelope_size bytes, there is always sufficient room.
7325            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CustomAttributeValue, 255>, D>(
7326            self.possible_values.as_ref().map(<fidl::encoding::Vector<CustomAttributeValue, 255> as fidl::encoding::ValueTypeMarker>::borrow),
7327            encoder, offset + cur_offset, depth
7328        )?;
7329
7330            _prev_end_offset = cur_offset + envelope_size;
7331            if 4 > max_ordinal {
7332                return Ok(());
7333            }
7334
7335            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7336            // are envelope_size bytes.
7337            let cur_offset: usize = (4 - 1) * envelope_size;
7338
7339            // Zero reserved fields.
7340            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7341
7342            // Safety:
7343            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7344            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7345            //   envelope_size bytes, there is always sufficient room.
7346            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7347                self.current_value.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7348                encoder,
7349                offset + cur_offset,
7350                depth,
7351            )?;
7352
7353            _prev_end_offset = cur_offset + envelope_size;
7354
7355            Ok(())
7356        }
7357    }
7358
7359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7360        for CustomPlayerApplicationSetting
7361    {
7362        #[inline(always)]
7363        fn new_empty() -> Self {
7364            Self::default()
7365        }
7366
7367        unsafe fn decode(
7368            &mut self,
7369            decoder: &mut fidl::encoding::Decoder<'_, D>,
7370            offset: usize,
7371            mut depth: fidl::encoding::Depth,
7372        ) -> fidl::Result<()> {
7373            decoder.debug_check_bounds::<Self>(offset);
7374            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7375                None => return Err(fidl::Error::NotNullable),
7376                Some(len) => len,
7377            };
7378            // Calling decoder.out_of_line_offset(0) is not allowed.
7379            if len == 0 {
7380                return Ok(());
7381            };
7382            depth.increment()?;
7383            let envelope_size = 8;
7384            let bytes_len = len * envelope_size;
7385            let offset = decoder.out_of_line_offset(bytes_len)?;
7386            // Decode the envelope for each type.
7387            let mut _next_ordinal_to_read = 0;
7388            let mut next_offset = offset;
7389            let end_offset = offset + bytes_len;
7390            _next_ordinal_to_read += 1;
7391            if next_offset >= end_offset {
7392                return Ok(());
7393            }
7394
7395            // Decode unknown envelopes for gaps in ordinals.
7396            while _next_ordinal_to_read < 1 {
7397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7398                _next_ordinal_to_read += 1;
7399                next_offset += envelope_size;
7400            }
7401
7402            let next_out_of_line = decoder.next_out_of_line();
7403            let handles_before = decoder.remaining_handles();
7404            if let Some((inlined, num_bytes, num_handles)) =
7405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7406            {
7407                let member_inline_size =
7408                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7409                if inlined != (member_inline_size <= 4) {
7410                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7411                }
7412                let inner_offset;
7413                let mut inner_depth = depth.clone();
7414                if inlined {
7415                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7416                    inner_offset = next_offset;
7417                } else {
7418                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7419                    inner_depth.increment()?;
7420                }
7421                let val_ref = self.attribute_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7422                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7423                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7424                {
7425                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7426                }
7427                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7428                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7429                }
7430            }
7431
7432            next_offset += envelope_size;
7433            _next_ordinal_to_read += 1;
7434            if next_offset >= end_offset {
7435                return Ok(());
7436            }
7437
7438            // Decode unknown envelopes for gaps in ordinals.
7439            while _next_ordinal_to_read < 2 {
7440                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7441                _next_ordinal_to_read += 1;
7442                next_offset += envelope_size;
7443            }
7444
7445            let next_out_of_line = decoder.next_out_of_line();
7446            let handles_before = decoder.remaining_handles();
7447            if let Some((inlined, num_bytes, num_handles)) =
7448                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7449            {
7450                let member_inline_size =
7451                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7452                        decoder.context,
7453                    );
7454                if inlined != (member_inline_size <= 4) {
7455                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7456                }
7457                let inner_offset;
7458                let mut inner_depth = depth.clone();
7459                if inlined {
7460                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7461                    inner_offset = next_offset;
7462                } else {
7463                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7464                    inner_depth.increment()?;
7465                }
7466                let val_ref = self
7467                    .attribute_name
7468                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7469                fidl::decode!(
7470                    fidl::encoding::BoundedString<255>,
7471                    D,
7472                    val_ref,
7473                    decoder,
7474                    inner_offset,
7475                    inner_depth
7476                )?;
7477                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7478                {
7479                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7480                }
7481                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7482                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7483                }
7484            }
7485
7486            next_offset += envelope_size;
7487            _next_ordinal_to_read += 1;
7488            if next_offset >= end_offset {
7489                return Ok(());
7490            }
7491
7492            // Decode unknown envelopes for gaps in ordinals.
7493            while _next_ordinal_to_read < 3 {
7494                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7495                _next_ordinal_to_read += 1;
7496                next_offset += envelope_size;
7497            }
7498
7499            let next_out_of_line = decoder.next_out_of_line();
7500            let handles_before = decoder.remaining_handles();
7501            if let Some((inlined, num_bytes, num_handles)) =
7502                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7503            {
7504                let member_inline_size = <fidl::encoding::Vector<CustomAttributeValue, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7505                if inlined != (member_inline_size <= 4) {
7506                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507                }
7508                let inner_offset;
7509                let mut inner_depth = depth.clone();
7510                if inlined {
7511                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512                    inner_offset = next_offset;
7513                } else {
7514                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515                    inner_depth.increment()?;
7516                }
7517                let val_ref = self.possible_values.get_or_insert_with(
7518                    || fidl::new_empty!(fidl::encoding::Vector<CustomAttributeValue, 255>, D),
7519                );
7520                fidl::decode!(fidl::encoding::Vector<CustomAttributeValue, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7521                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7522                {
7523                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7524                }
7525                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7526                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7527                }
7528            }
7529
7530            next_offset += envelope_size;
7531            _next_ordinal_to_read += 1;
7532            if next_offset >= end_offset {
7533                return Ok(());
7534            }
7535
7536            // Decode unknown envelopes for gaps in ordinals.
7537            while _next_ordinal_to_read < 4 {
7538                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7539                _next_ordinal_to_read += 1;
7540                next_offset += envelope_size;
7541            }
7542
7543            let next_out_of_line = decoder.next_out_of_line();
7544            let handles_before = decoder.remaining_handles();
7545            if let Some((inlined, num_bytes, num_handles)) =
7546                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7547            {
7548                let member_inline_size =
7549                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7550                if inlined != (member_inline_size <= 4) {
7551                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7552                }
7553                let inner_offset;
7554                let mut inner_depth = depth.clone();
7555                if inlined {
7556                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7557                    inner_offset = next_offset;
7558                } else {
7559                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7560                    inner_depth.increment()?;
7561                }
7562                let val_ref = self.current_value.get_or_insert_with(|| fidl::new_empty!(u8, D));
7563                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7564                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7565                {
7566                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7567                }
7568                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7569                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7570                }
7571            }
7572
7573            next_offset += envelope_size;
7574
7575            // Decode the remaining unknown envelopes.
7576            while next_offset < end_offset {
7577                _next_ordinal_to_read += 1;
7578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7579                next_offset += envelope_size;
7580            }
7581
7582            Ok(())
7583        }
7584    }
7585
7586    impl FolderItem {
7587        #[inline(always)]
7588        fn max_ordinal_present(&self) -> u64 {
7589            if let Some(_) = self.displayable_name {
7590                return 4;
7591            }
7592            if let Some(_) = self.is_playable {
7593                return 3;
7594            }
7595            if let Some(_) = self.folder_type {
7596                return 2;
7597            }
7598            if let Some(_) = self.folder_uid {
7599                return 1;
7600            }
7601            0
7602        }
7603    }
7604
7605    impl fidl::encoding::ValueTypeMarker for FolderItem {
7606        type Borrowed<'a> = &'a Self;
7607        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7608            value
7609        }
7610    }
7611
7612    unsafe impl fidl::encoding::TypeMarker for FolderItem {
7613        type Owned = Self;
7614
7615        #[inline(always)]
7616        fn inline_align(_context: fidl::encoding::Context) -> usize {
7617            8
7618        }
7619
7620        #[inline(always)]
7621        fn inline_size(_context: fidl::encoding::Context) -> usize {
7622            16
7623        }
7624    }
7625
7626    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FolderItem, D>
7627        for &FolderItem
7628    {
7629        unsafe fn encode(
7630            self,
7631            encoder: &mut fidl::encoding::Encoder<'_, D>,
7632            offset: usize,
7633            mut depth: fidl::encoding::Depth,
7634        ) -> fidl::Result<()> {
7635            encoder.debug_check_bounds::<FolderItem>(offset);
7636            // Vector header
7637            let max_ordinal: u64 = self.max_ordinal_present();
7638            encoder.write_num(max_ordinal, offset);
7639            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7640            // Calling encoder.out_of_line_offset(0) is not allowed.
7641            if max_ordinal == 0 {
7642                return Ok(());
7643            }
7644            depth.increment()?;
7645            let envelope_size = 8;
7646            let bytes_len = max_ordinal as usize * envelope_size;
7647            #[allow(unused_variables)]
7648            let offset = encoder.out_of_line_offset(bytes_len);
7649            let mut _prev_end_offset: usize = 0;
7650            if 1 > max_ordinal {
7651                return Ok(());
7652            }
7653
7654            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7655            // are envelope_size bytes.
7656            let cur_offset: usize = (1 - 1) * envelope_size;
7657
7658            // Zero reserved fields.
7659            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7660
7661            // Safety:
7662            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7663            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7664            //   envelope_size bytes, there is always sufficient room.
7665            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7666                self.folder_uid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7667                encoder,
7668                offset + cur_offset,
7669                depth,
7670            )?;
7671
7672            _prev_end_offset = cur_offset + envelope_size;
7673            if 2 > max_ordinal {
7674                return Ok(());
7675            }
7676
7677            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7678            // are envelope_size bytes.
7679            let cur_offset: usize = (2 - 1) * envelope_size;
7680
7681            // Zero reserved fields.
7682            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7683
7684            // Safety:
7685            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7686            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7687            //   envelope_size bytes, there is always sufficient room.
7688            fidl::encoding::encode_in_envelope_optional::<FolderType, D>(
7689                self.folder_type
7690                    .as_ref()
7691                    .map(<FolderType as fidl::encoding::ValueTypeMarker>::borrow),
7692                encoder,
7693                offset + cur_offset,
7694                depth,
7695            )?;
7696
7697            _prev_end_offset = cur_offset + envelope_size;
7698            if 3 > max_ordinal {
7699                return Ok(());
7700            }
7701
7702            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7703            // are envelope_size bytes.
7704            let cur_offset: usize = (3 - 1) * envelope_size;
7705
7706            // Zero reserved fields.
7707            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7708
7709            // Safety:
7710            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7711            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7712            //   envelope_size bytes, there is always sufficient room.
7713            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7714                self.is_playable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7715                encoder,
7716                offset + cur_offset,
7717                depth,
7718            )?;
7719
7720            _prev_end_offset = cur_offset + envelope_size;
7721            if 4 > max_ordinal {
7722                return Ok(());
7723            }
7724
7725            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7726            // are envelope_size bytes.
7727            let cur_offset: usize = (4 - 1) * envelope_size;
7728
7729            // Zero reserved fields.
7730            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7731
7732            // Safety:
7733            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7734            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7735            //   envelope_size bytes, there is always sufficient room.
7736            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7737                self.displayable_name.as_ref().map(
7738                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7739                ),
7740                encoder,
7741                offset + cur_offset,
7742                depth,
7743            )?;
7744
7745            _prev_end_offset = cur_offset + envelope_size;
7746
7747            Ok(())
7748        }
7749    }
7750
7751    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FolderItem {
7752        #[inline(always)]
7753        fn new_empty() -> Self {
7754            Self::default()
7755        }
7756
7757        unsafe fn decode(
7758            &mut self,
7759            decoder: &mut fidl::encoding::Decoder<'_, D>,
7760            offset: usize,
7761            mut depth: fidl::encoding::Depth,
7762        ) -> fidl::Result<()> {
7763            decoder.debug_check_bounds::<Self>(offset);
7764            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7765                None => return Err(fidl::Error::NotNullable),
7766                Some(len) => len,
7767            };
7768            // Calling decoder.out_of_line_offset(0) is not allowed.
7769            if len == 0 {
7770                return Ok(());
7771            };
7772            depth.increment()?;
7773            let envelope_size = 8;
7774            let bytes_len = len * envelope_size;
7775            let offset = decoder.out_of_line_offset(bytes_len)?;
7776            // Decode the envelope for each type.
7777            let mut _next_ordinal_to_read = 0;
7778            let mut next_offset = offset;
7779            let end_offset = offset + bytes_len;
7780            _next_ordinal_to_read += 1;
7781            if next_offset >= end_offset {
7782                return Ok(());
7783            }
7784
7785            // Decode unknown envelopes for gaps in ordinals.
7786            while _next_ordinal_to_read < 1 {
7787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7788                _next_ordinal_to_read += 1;
7789                next_offset += envelope_size;
7790            }
7791
7792            let next_out_of_line = decoder.next_out_of_line();
7793            let handles_before = decoder.remaining_handles();
7794            if let Some((inlined, num_bytes, num_handles)) =
7795                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7796            {
7797                let member_inline_size =
7798                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7799                if inlined != (member_inline_size <= 4) {
7800                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7801                }
7802                let inner_offset;
7803                let mut inner_depth = depth.clone();
7804                if inlined {
7805                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7806                    inner_offset = next_offset;
7807                } else {
7808                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7809                    inner_depth.increment()?;
7810                }
7811                let val_ref = self.folder_uid.get_or_insert_with(|| fidl::new_empty!(u64, D));
7812                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7813                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7814                {
7815                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7816                }
7817                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7818                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7819                }
7820            }
7821
7822            next_offset += envelope_size;
7823            _next_ordinal_to_read += 1;
7824            if next_offset >= end_offset {
7825                return Ok(());
7826            }
7827
7828            // Decode unknown envelopes for gaps in ordinals.
7829            while _next_ordinal_to_read < 2 {
7830                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7831                _next_ordinal_to_read += 1;
7832                next_offset += envelope_size;
7833            }
7834
7835            let next_out_of_line = decoder.next_out_of_line();
7836            let handles_before = decoder.remaining_handles();
7837            if let Some((inlined, num_bytes, num_handles)) =
7838                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7839            {
7840                let member_inline_size =
7841                    <FolderType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7842                if inlined != (member_inline_size <= 4) {
7843                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7844                }
7845                let inner_offset;
7846                let mut inner_depth = depth.clone();
7847                if inlined {
7848                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7849                    inner_offset = next_offset;
7850                } else {
7851                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7852                    inner_depth.increment()?;
7853                }
7854                let val_ref =
7855                    self.folder_type.get_or_insert_with(|| fidl::new_empty!(FolderType, D));
7856                fidl::decode!(FolderType, D, val_ref, decoder, inner_offset, inner_depth)?;
7857                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7858                {
7859                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7860                }
7861                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7862                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7863                }
7864            }
7865
7866            next_offset += envelope_size;
7867            _next_ordinal_to_read += 1;
7868            if next_offset >= end_offset {
7869                return Ok(());
7870            }
7871
7872            // Decode unknown envelopes for gaps in ordinals.
7873            while _next_ordinal_to_read < 3 {
7874                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7875                _next_ordinal_to_read += 1;
7876                next_offset += envelope_size;
7877            }
7878
7879            let next_out_of_line = decoder.next_out_of_line();
7880            let handles_before = decoder.remaining_handles();
7881            if let Some((inlined, num_bytes, num_handles)) =
7882                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7883            {
7884                let member_inline_size =
7885                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7886                if inlined != (member_inline_size <= 4) {
7887                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7888                }
7889                let inner_offset;
7890                let mut inner_depth = depth.clone();
7891                if inlined {
7892                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7893                    inner_offset = next_offset;
7894                } else {
7895                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7896                    inner_depth.increment()?;
7897                }
7898                let val_ref = self.is_playable.get_or_insert_with(|| fidl::new_empty!(bool, D));
7899                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7900                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7901                {
7902                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7903                }
7904                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7905                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7906                }
7907            }
7908
7909            next_offset += envelope_size;
7910            _next_ordinal_to_read += 1;
7911            if next_offset >= end_offset {
7912                return Ok(());
7913            }
7914
7915            // Decode unknown envelopes for gaps in ordinals.
7916            while _next_ordinal_to_read < 4 {
7917                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7918                _next_ordinal_to_read += 1;
7919                next_offset += envelope_size;
7920            }
7921
7922            let next_out_of_line = decoder.next_out_of_line();
7923            let handles_before = decoder.remaining_handles();
7924            if let Some((inlined, num_bytes, num_handles)) =
7925                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7926            {
7927                let member_inline_size =
7928                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7929                        decoder.context,
7930                    );
7931                if inlined != (member_inline_size <= 4) {
7932                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7933                }
7934                let inner_offset;
7935                let mut inner_depth = depth.clone();
7936                if inlined {
7937                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7938                    inner_offset = next_offset;
7939                } else {
7940                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7941                    inner_depth.increment()?;
7942                }
7943                let val_ref = self
7944                    .displayable_name
7945                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7946                fidl::decode!(
7947                    fidl::encoding::BoundedString<255>,
7948                    D,
7949                    val_ref,
7950                    decoder,
7951                    inner_offset,
7952                    inner_depth
7953                )?;
7954                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7955                {
7956                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7957                }
7958                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7959                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7960                }
7961            }
7962
7963            next_offset += envelope_size;
7964
7965            // Decode the remaining unknown envelopes.
7966            while next_offset < end_offset {
7967                _next_ordinal_to_read += 1;
7968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7969                next_offset += envelope_size;
7970            }
7971
7972            Ok(())
7973        }
7974    }
7975
7976    impl MediaAttributes {
7977        #[inline(always)]
7978        fn max_ordinal_present(&self) -> u64 {
7979            if let Some(_) = self.playing_time {
7980                return 7;
7981            }
7982            if let Some(_) = self.genre {
7983                return 6;
7984            }
7985            if let Some(_) = self.total_number_of_tracks {
7986                return 5;
7987            }
7988            if let Some(_) = self.track_number {
7989                return 4;
7990            }
7991            if let Some(_) = self.album_name {
7992                return 3;
7993            }
7994            if let Some(_) = self.artist_name {
7995                return 2;
7996            }
7997            if let Some(_) = self.title {
7998                return 1;
7999            }
8000            0
8001        }
8002    }
8003
8004    impl fidl::encoding::ValueTypeMarker for MediaAttributes {
8005        type Borrowed<'a> = &'a Self;
8006        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8007            value
8008        }
8009    }
8010
8011    unsafe impl fidl::encoding::TypeMarker for MediaAttributes {
8012        type Owned = Self;
8013
8014        #[inline(always)]
8015        fn inline_align(_context: fidl::encoding::Context) -> usize {
8016            8
8017        }
8018
8019        #[inline(always)]
8020        fn inline_size(_context: fidl::encoding::Context) -> usize {
8021            16
8022        }
8023    }
8024
8025    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaAttributes, D>
8026        for &MediaAttributes
8027    {
8028        unsafe fn encode(
8029            self,
8030            encoder: &mut fidl::encoding::Encoder<'_, D>,
8031            offset: usize,
8032            mut depth: fidl::encoding::Depth,
8033        ) -> fidl::Result<()> {
8034            encoder.debug_check_bounds::<MediaAttributes>(offset);
8035            // Vector header
8036            let max_ordinal: u64 = self.max_ordinal_present();
8037            encoder.write_num(max_ordinal, offset);
8038            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8039            // Calling encoder.out_of_line_offset(0) is not allowed.
8040            if max_ordinal == 0 {
8041                return Ok(());
8042            }
8043            depth.increment()?;
8044            let envelope_size = 8;
8045            let bytes_len = max_ordinal as usize * envelope_size;
8046            #[allow(unused_variables)]
8047            let offset = encoder.out_of_line_offset(bytes_len);
8048            let mut _prev_end_offset: usize = 0;
8049            if 1 > max_ordinal {
8050                return Ok(());
8051            }
8052
8053            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8054            // are envelope_size bytes.
8055            let cur_offset: usize = (1 - 1) * envelope_size;
8056
8057            // Zero reserved fields.
8058            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8059
8060            // Safety:
8061            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8062            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8063            //   envelope_size bytes, there is always sufficient room.
8064            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8065            self.title.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8066            encoder, offset + cur_offset, depth
8067        )?;
8068
8069            _prev_end_offset = cur_offset + envelope_size;
8070            if 2 > max_ordinal {
8071                return Ok(());
8072            }
8073
8074            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8075            // are envelope_size bytes.
8076            let cur_offset: usize = (2 - 1) * envelope_size;
8077
8078            // Zero reserved fields.
8079            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8080
8081            // Safety:
8082            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8083            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8084            //   envelope_size bytes, there is always sufficient room.
8085            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8086            self.artist_name.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8087            encoder, offset + cur_offset, depth
8088        )?;
8089
8090            _prev_end_offset = cur_offset + envelope_size;
8091            if 3 > max_ordinal {
8092                return Ok(());
8093            }
8094
8095            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8096            // are envelope_size bytes.
8097            let cur_offset: usize = (3 - 1) * envelope_size;
8098
8099            // Zero reserved fields.
8100            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8101
8102            // Safety:
8103            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8104            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8105            //   envelope_size bytes, there is always sufficient room.
8106            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8107            self.album_name.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8108            encoder, offset + cur_offset, depth
8109        )?;
8110
8111            _prev_end_offset = cur_offset + envelope_size;
8112            if 4 > max_ordinal {
8113                return Ok(());
8114            }
8115
8116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8117            // are envelope_size bytes.
8118            let cur_offset: usize = (4 - 1) * envelope_size;
8119
8120            // Zero reserved fields.
8121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8122
8123            // Safety:
8124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8126            //   envelope_size bytes, there is always sufficient room.
8127            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8128            self.track_number.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8129            encoder, offset + cur_offset, depth
8130        )?;
8131
8132            _prev_end_offset = cur_offset + envelope_size;
8133            if 5 > max_ordinal {
8134                return Ok(());
8135            }
8136
8137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8138            // are envelope_size bytes.
8139            let cur_offset: usize = (5 - 1) * envelope_size;
8140
8141            // Zero reserved fields.
8142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8143
8144            // Safety:
8145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8147            //   envelope_size bytes, there is always sufficient room.
8148            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8149            self.total_number_of_tracks.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8150            encoder, offset + cur_offset, depth
8151        )?;
8152
8153            _prev_end_offset = cur_offset + envelope_size;
8154            if 6 > max_ordinal {
8155                return Ok(());
8156            }
8157
8158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8159            // are envelope_size bytes.
8160            let cur_offset: usize = (6 - 1) * envelope_size;
8161
8162            // Zero reserved fields.
8163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8164
8165            // Safety:
8166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8168            //   envelope_size bytes, there is always sufficient room.
8169            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8170            self.genre.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8171            encoder, offset + cur_offset, depth
8172        )?;
8173
8174            _prev_end_offset = cur_offset + envelope_size;
8175            if 7 > max_ordinal {
8176                return Ok(());
8177            }
8178
8179            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8180            // are envelope_size bytes.
8181            let cur_offset: usize = (7 - 1) * envelope_size;
8182
8183            // Zero reserved fields.
8184            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8185
8186            // Safety:
8187            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8188            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8189            //   envelope_size bytes, there is always sufficient room.
8190            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8191            self.playing_time.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8192            encoder, offset + cur_offset, depth
8193        )?;
8194
8195            _prev_end_offset = cur_offset + envelope_size;
8196
8197            Ok(())
8198        }
8199    }
8200
8201    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaAttributes {
8202        #[inline(always)]
8203        fn new_empty() -> Self {
8204            Self::default()
8205        }
8206
8207        unsafe fn decode(
8208            &mut self,
8209            decoder: &mut fidl::encoding::Decoder<'_, D>,
8210            offset: usize,
8211            mut depth: fidl::encoding::Depth,
8212        ) -> fidl::Result<()> {
8213            decoder.debug_check_bounds::<Self>(offset);
8214            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8215                None => return Err(fidl::Error::NotNullable),
8216                Some(len) => len,
8217            };
8218            // Calling decoder.out_of_line_offset(0) is not allowed.
8219            if len == 0 {
8220                return Ok(());
8221            };
8222            depth.increment()?;
8223            let envelope_size = 8;
8224            let bytes_len = len * envelope_size;
8225            let offset = decoder.out_of_line_offset(bytes_len)?;
8226            // Decode the envelope for each type.
8227            let mut _next_ordinal_to_read = 0;
8228            let mut next_offset = offset;
8229            let end_offset = offset + bytes_len;
8230            _next_ordinal_to_read += 1;
8231            if next_offset >= end_offset {
8232                return Ok(());
8233            }
8234
8235            // Decode unknown envelopes for gaps in ordinals.
8236            while _next_ordinal_to_read < 1 {
8237                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8238                _next_ordinal_to_read += 1;
8239                next_offset += envelope_size;
8240            }
8241
8242            let next_out_of_line = decoder.next_out_of_line();
8243            let handles_before = decoder.remaining_handles();
8244            if let Some((inlined, num_bytes, num_handles)) =
8245                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8246            {
8247                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8248                if inlined != (member_inline_size <= 4) {
8249                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8250                }
8251                let inner_offset;
8252                let mut inner_depth = depth.clone();
8253                if inlined {
8254                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8255                    inner_offset = next_offset;
8256                } else {
8257                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8258                    inner_depth.increment()?;
8259                }
8260                let val_ref = self.title.get_or_insert_with(|| {
8261                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8262                });
8263                fidl::decode!(
8264                    fidl::encoding::BoundedString<65535>,
8265                    D,
8266                    val_ref,
8267                    decoder,
8268                    inner_offset,
8269                    inner_depth
8270                )?;
8271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8272                {
8273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8274                }
8275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8277                }
8278            }
8279
8280            next_offset += envelope_size;
8281            _next_ordinal_to_read += 1;
8282            if next_offset >= end_offset {
8283                return Ok(());
8284            }
8285
8286            // Decode unknown envelopes for gaps in ordinals.
8287            while _next_ordinal_to_read < 2 {
8288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8289                _next_ordinal_to_read += 1;
8290                next_offset += envelope_size;
8291            }
8292
8293            let next_out_of_line = decoder.next_out_of_line();
8294            let handles_before = decoder.remaining_handles();
8295            if let Some((inlined, num_bytes, num_handles)) =
8296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8297            {
8298                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8299                if inlined != (member_inline_size <= 4) {
8300                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8301                }
8302                let inner_offset;
8303                let mut inner_depth = depth.clone();
8304                if inlined {
8305                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8306                    inner_offset = next_offset;
8307                } else {
8308                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8309                    inner_depth.increment()?;
8310                }
8311                let val_ref = self.artist_name.get_or_insert_with(|| {
8312                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8313                });
8314                fidl::decode!(
8315                    fidl::encoding::BoundedString<65535>,
8316                    D,
8317                    val_ref,
8318                    decoder,
8319                    inner_offset,
8320                    inner_depth
8321                )?;
8322                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8323                {
8324                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8325                }
8326                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8327                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8328                }
8329            }
8330
8331            next_offset += envelope_size;
8332            _next_ordinal_to_read += 1;
8333            if next_offset >= end_offset {
8334                return Ok(());
8335            }
8336
8337            // Decode unknown envelopes for gaps in ordinals.
8338            while _next_ordinal_to_read < 3 {
8339                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8340                _next_ordinal_to_read += 1;
8341                next_offset += envelope_size;
8342            }
8343
8344            let next_out_of_line = decoder.next_out_of_line();
8345            let handles_before = decoder.remaining_handles();
8346            if let Some((inlined, num_bytes, num_handles)) =
8347                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8348            {
8349                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8350                if inlined != (member_inline_size <= 4) {
8351                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8352                }
8353                let inner_offset;
8354                let mut inner_depth = depth.clone();
8355                if inlined {
8356                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8357                    inner_offset = next_offset;
8358                } else {
8359                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8360                    inner_depth.increment()?;
8361                }
8362                let val_ref = self.album_name.get_or_insert_with(|| {
8363                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8364                });
8365                fidl::decode!(
8366                    fidl::encoding::BoundedString<65535>,
8367                    D,
8368                    val_ref,
8369                    decoder,
8370                    inner_offset,
8371                    inner_depth
8372                )?;
8373                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8374                {
8375                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8376                }
8377                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8378                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8379                }
8380            }
8381
8382            next_offset += envelope_size;
8383            _next_ordinal_to_read += 1;
8384            if next_offset >= end_offset {
8385                return Ok(());
8386            }
8387
8388            // Decode unknown envelopes for gaps in ordinals.
8389            while _next_ordinal_to_read < 4 {
8390                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8391                _next_ordinal_to_read += 1;
8392                next_offset += envelope_size;
8393            }
8394
8395            let next_out_of_line = decoder.next_out_of_line();
8396            let handles_before = decoder.remaining_handles();
8397            if let Some((inlined, num_bytes, num_handles)) =
8398                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8399            {
8400                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8401                if inlined != (member_inline_size <= 4) {
8402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8403                }
8404                let inner_offset;
8405                let mut inner_depth = depth.clone();
8406                if inlined {
8407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8408                    inner_offset = next_offset;
8409                } else {
8410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8411                    inner_depth.increment()?;
8412                }
8413                let val_ref = self.track_number.get_or_insert_with(|| {
8414                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8415                });
8416                fidl::decode!(
8417                    fidl::encoding::BoundedString<65535>,
8418                    D,
8419                    val_ref,
8420                    decoder,
8421                    inner_offset,
8422                    inner_depth
8423                )?;
8424                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8425                {
8426                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8427                }
8428                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8429                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8430                }
8431            }
8432
8433            next_offset += envelope_size;
8434            _next_ordinal_to_read += 1;
8435            if next_offset >= end_offset {
8436                return Ok(());
8437            }
8438
8439            // Decode unknown envelopes for gaps in ordinals.
8440            while _next_ordinal_to_read < 5 {
8441                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8442                _next_ordinal_to_read += 1;
8443                next_offset += envelope_size;
8444            }
8445
8446            let next_out_of_line = decoder.next_out_of_line();
8447            let handles_before = decoder.remaining_handles();
8448            if let Some((inlined, num_bytes, num_handles)) =
8449                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8450            {
8451                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8452                if inlined != (member_inline_size <= 4) {
8453                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8454                }
8455                let inner_offset;
8456                let mut inner_depth = depth.clone();
8457                if inlined {
8458                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8459                    inner_offset = next_offset;
8460                } else {
8461                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8462                    inner_depth.increment()?;
8463                }
8464                let val_ref = self.total_number_of_tracks.get_or_insert_with(|| {
8465                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8466                });
8467                fidl::decode!(
8468                    fidl::encoding::BoundedString<65535>,
8469                    D,
8470                    val_ref,
8471                    decoder,
8472                    inner_offset,
8473                    inner_depth
8474                )?;
8475                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8476                {
8477                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8478                }
8479                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8480                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8481                }
8482            }
8483
8484            next_offset += envelope_size;
8485            _next_ordinal_to_read += 1;
8486            if next_offset >= end_offset {
8487                return Ok(());
8488            }
8489
8490            // Decode unknown envelopes for gaps in ordinals.
8491            while _next_ordinal_to_read < 6 {
8492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8493                _next_ordinal_to_read += 1;
8494                next_offset += envelope_size;
8495            }
8496
8497            let next_out_of_line = decoder.next_out_of_line();
8498            let handles_before = decoder.remaining_handles();
8499            if let Some((inlined, num_bytes, num_handles)) =
8500                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8501            {
8502                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8503                if inlined != (member_inline_size <= 4) {
8504                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8505                }
8506                let inner_offset;
8507                let mut inner_depth = depth.clone();
8508                if inlined {
8509                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8510                    inner_offset = next_offset;
8511                } else {
8512                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8513                    inner_depth.increment()?;
8514                }
8515                let val_ref = self.genre.get_or_insert_with(|| {
8516                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8517                });
8518                fidl::decode!(
8519                    fidl::encoding::BoundedString<65535>,
8520                    D,
8521                    val_ref,
8522                    decoder,
8523                    inner_offset,
8524                    inner_depth
8525                )?;
8526                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8527                {
8528                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8529                }
8530                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8531                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8532                }
8533            }
8534
8535            next_offset += envelope_size;
8536            _next_ordinal_to_read += 1;
8537            if next_offset >= end_offset {
8538                return Ok(());
8539            }
8540
8541            // Decode unknown envelopes for gaps in ordinals.
8542            while _next_ordinal_to_read < 7 {
8543                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8544                _next_ordinal_to_read += 1;
8545                next_offset += envelope_size;
8546            }
8547
8548            let next_out_of_line = decoder.next_out_of_line();
8549            let handles_before = decoder.remaining_handles();
8550            if let Some((inlined, num_bytes, num_handles)) =
8551                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8552            {
8553                let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8554                if inlined != (member_inline_size <= 4) {
8555                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8556                }
8557                let inner_offset;
8558                let mut inner_depth = depth.clone();
8559                if inlined {
8560                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8561                    inner_offset = next_offset;
8562                } else {
8563                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8564                    inner_depth.increment()?;
8565                }
8566                let val_ref = self.playing_time.get_or_insert_with(|| {
8567                    fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8568                });
8569                fidl::decode!(
8570                    fidl::encoding::BoundedString<65535>,
8571                    D,
8572                    val_ref,
8573                    decoder,
8574                    inner_offset,
8575                    inner_depth
8576                )?;
8577                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8578                {
8579                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8580                }
8581                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8582                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8583                }
8584            }
8585
8586            next_offset += envelope_size;
8587
8588            // Decode the remaining unknown envelopes.
8589            while next_offset < end_offset {
8590                _next_ordinal_to_read += 1;
8591                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8592                next_offset += envelope_size;
8593            }
8594
8595            Ok(())
8596        }
8597    }
8598
8599    impl MediaElementItem {
8600        #[inline(always)]
8601        fn max_ordinal_present(&self) -> u64 {
8602            if let Some(_) = self.attributes {
8603                return 4;
8604            }
8605            if let Some(_) = self.displayable_name {
8606                return 3;
8607            }
8608            if let Some(_) = self.media_type {
8609                return 2;
8610            }
8611            if let Some(_) = self.media_element_uid {
8612                return 1;
8613            }
8614            0
8615        }
8616    }
8617
8618    impl fidl::encoding::ValueTypeMarker for MediaElementItem {
8619        type Borrowed<'a> = &'a Self;
8620        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8621            value
8622        }
8623    }
8624
8625    unsafe impl fidl::encoding::TypeMarker for MediaElementItem {
8626        type Owned = Self;
8627
8628        #[inline(always)]
8629        fn inline_align(_context: fidl::encoding::Context) -> usize {
8630            8
8631        }
8632
8633        #[inline(always)]
8634        fn inline_size(_context: fidl::encoding::Context) -> usize {
8635            16
8636        }
8637    }
8638
8639    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaElementItem, D>
8640        for &MediaElementItem
8641    {
8642        unsafe fn encode(
8643            self,
8644            encoder: &mut fidl::encoding::Encoder<'_, D>,
8645            offset: usize,
8646            mut depth: fidl::encoding::Depth,
8647        ) -> fidl::Result<()> {
8648            encoder.debug_check_bounds::<MediaElementItem>(offset);
8649            // Vector header
8650            let max_ordinal: u64 = self.max_ordinal_present();
8651            encoder.write_num(max_ordinal, offset);
8652            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8653            // Calling encoder.out_of_line_offset(0) is not allowed.
8654            if max_ordinal == 0 {
8655                return Ok(());
8656            }
8657            depth.increment()?;
8658            let envelope_size = 8;
8659            let bytes_len = max_ordinal as usize * envelope_size;
8660            #[allow(unused_variables)]
8661            let offset = encoder.out_of_line_offset(bytes_len);
8662            let mut _prev_end_offset: usize = 0;
8663            if 1 > max_ordinal {
8664                return Ok(());
8665            }
8666
8667            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8668            // are envelope_size bytes.
8669            let cur_offset: usize = (1 - 1) * envelope_size;
8670
8671            // Zero reserved fields.
8672            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8673
8674            // Safety:
8675            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8676            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8677            //   envelope_size bytes, there is always sufficient room.
8678            fidl::encoding::encode_in_envelope_optional::<u64, D>(
8679                self.media_element_uid
8680                    .as_ref()
8681                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8682                encoder,
8683                offset + cur_offset,
8684                depth,
8685            )?;
8686
8687            _prev_end_offset = cur_offset + envelope_size;
8688            if 2 > max_ordinal {
8689                return Ok(());
8690            }
8691
8692            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8693            // are envelope_size bytes.
8694            let cur_offset: usize = (2 - 1) * envelope_size;
8695
8696            // Zero reserved fields.
8697            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8698
8699            // Safety:
8700            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8701            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8702            //   envelope_size bytes, there is always sufficient room.
8703            fidl::encoding::encode_in_envelope_optional::<MediaType, D>(
8704                self.media_type
8705                    .as_ref()
8706                    .map(<MediaType as fidl::encoding::ValueTypeMarker>::borrow),
8707                encoder,
8708                offset + cur_offset,
8709                depth,
8710            )?;
8711
8712            _prev_end_offset = cur_offset + envelope_size;
8713            if 3 > max_ordinal {
8714                return Ok(());
8715            }
8716
8717            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8718            // are envelope_size bytes.
8719            let cur_offset: usize = (3 - 1) * envelope_size;
8720
8721            // Zero reserved fields.
8722            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8723
8724            // Safety:
8725            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8726            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8727            //   envelope_size bytes, there is always sufficient room.
8728            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
8729                self.displayable_name.as_ref().map(
8730                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
8731                ),
8732                encoder,
8733                offset + cur_offset,
8734                depth,
8735            )?;
8736
8737            _prev_end_offset = cur_offset + envelope_size;
8738            if 4 > max_ordinal {
8739                return Ok(());
8740            }
8741
8742            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8743            // are envelope_size bytes.
8744            let cur_offset: usize = (4 - 1) * envelope_size;
8745
8746            // Zero reserved fields.
8747            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8748
8749            // Safety:
8750            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8751            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8752            //   envelope_size bytes, there is always sufficient room.
8753            fidl::encoding::encode_in_envelope_optional::<MediaAttributes, D>(
8754                self.attributes
8755                    .as_ref()
8756                    .map(<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow),
8757                encoder,
8758                offset + cur_offset,
8759                depth,
8760            )?;
8761
8762            _prev_end_offset = cur_offset + envelope_size;
8763
8764            Ok(())
8765        }
8766    }
8767
8768    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaElementItem {
8769        #[inline(always)]
8770        fn new_empty() -> Self {
8771            Self::default()
8772        }
8773
8774        unsafe fn decode(
8775            &mut self,
8776            decoder: &mut fidl::encoding::Decoder<'_, D>,
8777            offset: usize,
8778            mut depth: fidl::encoding::Depth,
8779        ) -> fidl::Result<()> {
8780            decoder.debug_check_bounds::<Self>(offset);
8781            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8782                None => return Err(fidl::Error::NotNullable),
8783                Some(len) => len,
8784            };
8785            // Calling decoder.out_of_line_offset(0) is not allowed.
8786            if len == 0 {
8787                return Ok(());
8788            };
8789            depth.increment()?;
8790            let envelope_size = 8;
8791            let bytes_len = len * envelope_size;
8792            let offset = decoder.out_of_line_offset(bytes_len)?;
8793            // Decode the envelope for each type.
8794            let mut _next_ordinal_to_read = 0;
8795            let mut next_offset = offset;
8796            let end_offset = offset + bytes_len;
8797            _next_ordinal_to_read += 1;
8798            if next_offset >= end_offset {
8799                return Ok(());
8800            }
8801
8802            // Decode unknown envelopes for gaps in ordinals.
8803            while _next_ordinal_to_read < 1 {
8804                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8805                _next_ordinal_to_read += 1;
8806                next_offset += envelope_size;
8807            }
8808
8809            let next_out_of_line = decoder.next_out_of_line();
8810            let handles_before = decoder.remaining_handles();
8811            if let Some((inlined, num_bytes, num_handles)) =
8812                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8813            {
8814                let member_inline_size =
8815                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8816                if inlined != (member_inline_size <= 4) {
8817                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8818                }
8819                let inner_offset;
8820                let mut inner_depth = depth.clone();
8821                if inlined {
8822                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8823                    inner_offset = next_offset;
8824                } else {
8825                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8826                    inner_depth.increment()?;
8827                }
8828                let val_ref =
8829                    self.media_element_uid.get_or_insert_with(|| fidl::new_empty!(u64, D));
8830                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8831                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8832                {
8833                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8834                }
8835                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8836                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8837                }
8838            }
8839
8840            next_offset += envelope_size;
8841            _next_ordinal_to_read += 1;
8842            if next_offset >= end_offset {
8843                return Ok(());
8844            }
8845
8846            // Decode unknown envelopes for gaps in ordinals.
8847            while _next_ordinal_to_read < 2 {
8848                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8849                _next_ordinal_to_read += 1;
8850                next_offset += envelope_size;
8851            }
8852
8853            let next_out_of_line = decoder.next_out_of_line();
8854            let handles_before = decoder.remaining_handles();
8855            if let Some((inlined, num_bytes, num_handles)) =
8856                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8857            {
8858                let member_inline_size =
8859                    <MediaType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8860                if inlined != (member_inline_size <= 4) {
8861                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8862                }
8863                let inner_offset;
8864                let mut inner_depth = depth.clone();
8865                if inlined {
8866                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8867                    inner_offset = next_offset;
8868                } else {
8869                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8870                    inner_depth.increment()?;
8871                }
8872                let val_ref = self.media_type.get_or_insert_with(|| fidl::new_empty!(MediaType, D));
8873                fidl::decode!(MediaType, D, val_ref, decoder, inner_offset, inner_depth)?;
8874                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8875                {
8876                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8877                }
8878                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8879                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8880                }
8881            }
8882
8883            next_offset += envelope_size;
8884            _next_ordinal_to_read += 1;
8885            if next_offset >= end_offset {
8886                return Ok(());
8887            }
8888
8889            // Decode unknown envelopes for gaps in ordinals.
8890            while _next_ordinal_to_read < 3 {
8891                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8892                _next_ordinal_to_read += 1;
8893                next_offset += envelope_size;
8894            }
8895
8896            let next_out_of_line = decoder.next_out_of_line();
8897            let handles_before = decoder.remaining_handles();
8898            if let Some((inlined, num_bytes, num_handles)) =
8899                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8900            {
8901                let member_inline_size =
8902                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
8903                        decoder.context,
8904                    );
8905                if inlined != (member_inline_size <= 4) {
8906                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8907                }
8908                let inner_offset;
8909                let mut inner_depth = depth.clone();
8910                if inlined {
8911                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8912                    inner_offset = next_offset;
8913                } else {
8914                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8915                    inner_depth.increment()?;
8916                }
8917                let val_ref = self
8918                    .displayable_name
8919                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
8920                fidl::decode!(
8921                    fidl::encoding::BoundedString<255>,
8922                    D,
8923                    val_ref,
8924                    decoder,
8925                    inner_offset,
8926                    inner_depth
8927                )?;
8928                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8929                {
8930                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8931                }
8932                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8933                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8934                }
8935            }
8936
8937            next_offset += envelope_size;
8938            _next_ordinal_to_read += 1;
8939            if next_offset >= end_offset {
8940                return Ok(());
8941            }
8942
8943            // Decode unknown envelopes for gaps in ordinals.
8944            while _next_ordinal_to_read < 4 {
8945                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8946                _next_ordinal_to_read += 1;
8947                next_offset += envelope_size;
8948            }
8949
8950            let next_out_of_line = decoder.next_out_of_line();
8951            let handles_before = decoder.remaining_handles();
8952            if let Some((inlined, num_bytes, num_handles)) =
8953                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8954            {
8955                let member_inline_size =
8956                    <MediaAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8957                if inlined != (member_inline_size <= 4) {
8958                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8959                }
8960                let inner_offset;
8961                let mut inner_depth = depth.clone();
8962                if inlined {
8963                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8964                    inner_offset = next_offset;
8965                } else {
8966                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8967                    inner_depth.increment()?;
8968                }
8969                let val_ref =
8970                    self.attributes.get_or_insert_with(|| fidl::new_empty!(MediaAttributes, D));
8971                fidl::decode!(MediaAttributes, D, val_ref, decoder, inner_offset, inner_depth)?;
8972                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8973                {
8974                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8975                }
8976                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8977                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8978                }
8979            }
8980
8981            next_offset += envelope_size;
8982
8983            // Decode the remaining unknown envelopes.
8984            while next_offset < end_offset {
8985                _next_ordinal_to_read += 1;
8986                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8987                next_offset += envelope_size;
8988            }
8989
8990            Ok(())
8991        }
8992    }
8993
8994    impl MediaPlayerItem {
8995        #[inline(always)]
8996        fn max_ordinal_present(&self) -> u64 {
8997            if let Some(_) = self.feature_bits_ext {
8998                return 7;
8999            }
9000            if let Some(_) = self.feature_bits {
9001                return 6;
9002            }
9003            if let Some(_) = self.displayable_name {
9004                return 5;
9005            }
9006            if let Some(_) = self.playback_status {
9007                return 4;
9008            }
9009            if let Some(_) = self.sub_type {
9010                return 3;
9011            }
9012            if let Some(_) = self.major_type {
9013                return 2;
9014            }
9015            if let Some(_) = self.player_id {
9016                return 1;
9017            }
9018            0
9019        }
9020    }
9021
9022    impl fidl::encoding::ValueTypeMarker for MediaPlayerItem {
9023        type Borrowed<'a> = &'a Self;
9024        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9025            value
9026        }
9027    }
9028
9029    unsafe impl fidl::encoding::TypeMarker for MediaPlayerItem {
9030        type Owned = Self;
9031
9032        #[inline(always)]
9033        fn inline_align(_context: fidl::encoding::Context) -> usize {
9034            8
9035        }
9036
9037        #[inline(always)]
9038        fn inline_size(_context: fidl::encoding::Context) -> usize {
9039            16
9040        }
9041    }
9042
9043    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaPlayerItem, D>
9044        for &MediaPlayerItem
9045    {
9046        unsafe fn encode(
9047            self,
9048            encoder: &mut fidl::encoding::Encoder<'_, D>,
9049            offset: usize,
9050            mut depth: fidl::encoding::Depth,
9051        ) -> fidl::Result<()> {
9052            encoder.debug_check_bounds::<MediaPlayerItem>(offset);
9053            // Vector header
9054            let max_ordinal: u64 = self.max_ordinal_present();
9055            encoder.write_num(max_ordinal, offset);
9056            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9057            // Calling encoder.out_of_line_offset(0) is not allowed.
9058            if max_ordinal == 0 {
9059                return Ok(());
9060            }
9061            depth.increment()?;
9062            let envelope_size = 8;
9063            let bytes_len = max_ordinal as usize * envelope_size;
9064            #[allow(unused_variables)]
9065            let offset = encoder.out_of_line_offset(bytes_len);
9066            let mut _prev_end_offset: usize = 0;
9067            if 1 > max_ordinal {
9068                return Ok(());
9069            }
9070
9071            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9072            // are envelope_size bytes.
9073            let cur_offset: usize = (1 - 1) * envelope_size;
9074
9075            // Zero reserved fields.
9076            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9077
9078            // Safety:
9079            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9080            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9081            //   envelope_size bytes, there is always sufficient room.
9082            fidl::encoding::encode_in_envelope_optional::<u16, D>(
9083                self.player_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9084                encoder,
9085                offset + cur_offset,
9086                depth,
9087            )?;
9088
9089            _prev_end_offset = cur_offset + envelope_size;
9090            if 2 > max_ordinal {
9091                return Ok(());
9092            }
9093
9094            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9095            // are envelope_size bytes.
9096            let cur_offset: usize = (2 - 1) * envelope_size;
9097
9098            // Zero reserved fields.
9099            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9100
9101            // Safety:
9102            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9103            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9104            //   envelope_size bytes, there is always sufficient room.
9105            fidl::encoding::encode_in_envelope_optional::<MajorPlayerType, D>(
9106                self.major_type
9107                    .as_ref()
9108                    .map(<MajorPlayerType as fidl::encoding::ValueTypeMarker>::borrow),
9109                encoder,
9110                offset + cur_offset,
9111                depth,
9112            )?;
9113
9114            _prev_end_offset = cur_offset + envelope_size;
9115            if 3 > max_ordinal {
9116                return Ok(());
9117            }
9118
9119            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9120            // are envelope_size bytes.
9121            let cur_offset: usize = (3 - 1) * envelope_size;
9122
9123            // Zero reserved fields.
9124            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9125
9126            // Safety:
9127            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9128            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9129            //   envelope_size bytes, there is always sufficient room.
9130            fidl::encoding::encode_in_envelope_optional::<PlayerSubType, D>(
9131                self.sub_type
9132                    .as_ref()
9133                    .map(<PlayerSubType as fidl::encoding::ValueTypeMarker>::borrow),
9134                encoder,
9135                offset + cur_offset,
9136                depth,
9137            )?;
9138
9139            _prev_end_offset = cur_offset + envelope_size;
9140            if 4 > max_ordinal {
9141                return Ok(());
9142            }
9143
9144            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9145            // are envelope_size bytes.
9146            let cur_offset: usize = (4 - 1) * envelope_size;
9147
9148            // Zero reserved fields.
9149            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9150
9151            // Safety:
9152            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9153            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9154            //   envelope_size bytes, there is always sufficient room.
9155            fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
9156                self.playback_status
9157                    .as_ref()
9158                    .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
9159                encoder,
9160                offset + cur_offset,
9161                depth,
9162            )?;
9163
9164            _prev_end_offset = cur_offset + envelope_size;
9165            if 5 > max_ordinal {
9166                return Ok(());
9167            }
9168
9169            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9170            // are envelope_size bytes.
9171            let cur_offset: usize = (5 - 1) * envelope_size;
9172
9173            // Zero reserved fields.
9174            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9175
9176            // Safety:
9177            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9178            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9179            //   envelope_size bytes, there is always sufficient room.
9180            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
9181                self.displayable_name.as_ref().map(
9182                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
9183                ),
9184                encoder,
9185                offset + cur_offset,
9186                depth,
9187            )?;
9188
9189            _prev_end_offset = cur_offset + envelope_size;
9190            if 6 > max_ordinal {
9191                return Ok(());
9192            }
9193
9194            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9195            // are envelope_size bytes.
9196            let cur_offset: usize = (6 - 1) * envelope_size;
9197
9198            // Zero reserved fields.
9199            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9200
9201            // Safety:
9202            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9203            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9204            //   envelope_size bytes, there is always sufficient room.
9205            fidl::encoding::encode_in_envelope_optional::<PlayerFeatureBits, D>(
9206                self.feature_bits
9207                    .as_ref()
9208                    .map(<PlayerFeatureBits as fidl::encoding::ValueTypeMarker>::borrow),
9209                encoder,
9210                offset + cur_offset,
9211                depth,
9212            )?;
9213
9214            _prev_end_offset = cur_offset + envelope_size;
9215            if 7 > max_ordinal {
9216                return Ok(());
9217            }
9218
9219            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9220            // are envelope_size bytes.
9221            let cur_offset: usize = (7 - 1) * envelope_size;
9222
9223            // Zero reserved fields.
9224            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9225
9226            // Safety:
9227            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9228            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9229            //   envelope_size bytes, there is always sufficient room.
9230            fidl::encoding::encode_in_envelope_optional::<PlayerFeatureBitsExt, D>(
9231                self.feature_bits_ext
9232                    .as_ref()
9233                    .map(<PlayerFeatureBitsExt as fidl::encoding::ValueTypeMarker>::borrow),
9234                encoder,
9235                offset + cur_offset,
9236                depth,
9237            )?;
9238
9239            _prev_end_offset = cur_offset + envelope_size;
9240
9241            Ok(())
9242        }
9243    }
9244
9245    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaPlayerItem {
9246        #[inline(always)]
9247        fn new_empty() -> Self {
9248            Self::default()
9249        }
9250
9251        unsafe fn decode(
9252            &mut self,
9253            decoder: &mut fidl::encoding::Decoder<'_, D>,
9254            offset: usize,
9255            mut depth: fidl::encoding::Depth,
9256        ) -> fidl::Result<()> {
9257            decoder.debug_check_bounds::<Self>(offset);
9258            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9259                None => return Err(fidl::Error::NotNullable),
9260                Some(len) => len,
9261            };
9262            // Calling decoder.out_of_line_offset(0) is not allowed.
9263            if len == 0 {
9264                return Ok(());
9265            };
9266            depth.increment()?;
9267            let envelope_size = 8;
9268            let bytes_len = len * envelope_size;
9269            let offset = decoder.out_of_line_offset(bytes_len)?;
9270            // Decode the envelope for each type.
9271            let mut _next_ordinal_to_read = 0;
9272            let mut next_offset = offset;
9273            let end_offset = offset + bytes_len;
9274            _next_ordinal_to_read += 1;
9275            if next_offset >= end_offset {
9276                return Ok(());
9277            }
9278
9279            // Decode unknown envelopes for gaps in ordinals.
9280            while _next_ordinal_to_read < 1 {
9281                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9282                _next_ordinal_to_read += 1;
9283                next_offset += envelope_size;
9284            }
9285
9286            let next_out_of_line = decoder.next_out_of_line();
9287            let handles_before = decoder.remaining_handles();
9288            if let Some((inlined, num_bytes, num_handles)) =
9289                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9290            {
9291                let member_inline_size =
9292                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9293                if inlined != (member_inline_size <= 4) {
9294                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9295                }
9296                let inner_offset;
9297                let mut inner_depth = depth.clone();
9298                if inlined {
9299                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9300                    inner_offset = next_offset;
9301                } else {
9302                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9303                    inner_depth.increment()?;
9304                }
9305                let val_ref = self.player_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9306                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9307                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9308                {
9309                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9310                }
9311                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9312                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9313                }
9314            }
9315
9316            next_offset += envelope_size;
9317            _next_ordinal_to_read += 1;
9318            if next_offset >= end_offset {
9319                return Ok(());
9320            }
9321
9322            // Decode unknown envelopes for gaps in ordinals.
9323            while _next_ordinal_to_read < 2 {
9324                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9325                _next_ordinal_to_read += 1;
9326                next_offset += envelope_size;
9327            }
9328
9329            let next_out_of_line = decoder.next_out_of_line();
9330            let handles_before = decoder.remaining_handles();
9331            if let Some((inlined, num_bytes, num_handles)) =
9332                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9333            {
9334                let member_inline_size =
9335                    <MajorPlayerType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9336                if inlined != (member_inline_size <= 4) {
9337                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9338                }
9339                let inner_offset;
9340                let mut inner_depth = depth.clone();
9341                if inlined {
9342                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9343                    inner_offset = next_offset;
9344                } else {
9345                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9346                    inner_depth.increment()?;
9347                }
9348                let val_ref =
9349                    self.major_type.get_or_insert_with(|| fidl::new_empty!(MajorPlayerType, D));
9350                fidl::decode!(MajorPlayerType, D, val_ref, decoder, inner_offset, inner_depth)?;
9351                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9352                {
9353                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9354                }
9355                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9356                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9357                }
9358            }
9359
9360            next_offset += envelope_size;
9361            _next_ordinal_to_read += 1;
9362            if next_offset >= end_offset {
9363                return Ok(());
9364            }
9365
9366            // Decode unknown envelopes for gaps in ordinals.
9367            while _next_ordinal_to_read < 3 {
9368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9369                _next_ordinal_to_read += 1;
9370                next_offset += envelope_size;
9371            }
9372
9373            let next_out_of_line = decoder.next_out_of_line();
9374            let handles_before = decoder.remaining_handles();
9375            if let Some((inlined, num_bytes, num_handles)) =
9376                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9377            {
9378                let member_inline_size =
9379                    <PlayerSubType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9380                if inlined != (member_inline_size <= 4) {
9381                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9382                }
9383                let inner_offset;
9384                let mut inner_depth = depth.clone();
9385                if inlined {
9386                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9387                    inner_offset = next_offset;
9388                } else {
9389                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9390                    inner_depth.increment()?;
9391                }
9392                let val_ref =
9393                    self.sub_type.get_or_insert_with(|| fidl::new_empty!(PlayerSubType, D));
9394                fidl::decode!(PlayerSubType, D, val_ref, decoder, inner_offset, inner_depth)?;
9395                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9396                {
9397                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9398                }
9399                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9400                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9401                }
9402            }
9403
9404            next_offset += envelope_size;
9405            _next_ordinal_to_read += 1;
9406            if next_offset >= end_offset {
9407                return Ok(());
9408            }
9409
9410            // Decode unknown envelopes for gaps in ordinals.
9411            while _next_ordinal_to_read < 4 {
9412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9413                _next_ordinal_to_read += 1;
9414                next_offset += envelope_size;
9415            }
9416
9417            let next_out_of_line = decoder.next_out_of_line();
9418            let handles_before = decoder.remaining_handles();
9419            if let Some((inlined, num_bytes, num_handles)) =
9420                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9421            {
9422                let member_inline_size =
9423                    <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9424                if inlined != (member_inline_size <= 4) {
9425                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9426                }
9427                let inner_offset;
9428                let mut inner_depth = depth.clone();
9429                if inlined {
9430                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9431                    inner_offset = next_offset;
9432                } else {
9433                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9434                    inner_depth.increment()?;
9435                }
9436                let val_ref =
9437                    self.playback_status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
9438                fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
9439                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9440                {
9441                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9442                }
9443                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9444                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9445                }
9446            }
9447
9448            next_offset += envelope_size;
9449            _next_ordinal_to_read += 1;
9450            if next_offset >= end_offset {
9451                return Ok(());
9452            }
9453
9454            // Decode unknown envelopes for gaps in ordinals.
9455            while _next_ordinal_to_read < 5 {
9456                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9457                _next_ordinal_to_read += 1;
9458                next_offset += envelope_size;
9459            }
9460
9461            let next_out_of_line = decoder.next_out_of_line();
9462            let handles_before = decoder.remaining_handles();
9463            if let Some((inlined, num_bytes, num_handles)) =
9464                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9465            {
9466                let member_inline_size =
9467                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
9468                        decoder.context,
9469                    );
9470                if inlined != (member_inline_size <= 4) {
9471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9472                }
9473                let inner_offset;
9474                let mut inner_depth = depth.clone();
9475                if inlined {
9476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9477                    inner_offset = next_offset;
9478                } else {
9479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9480                    inner_depth.increment()?;
9481                }
9482                let val_ref = self
9483                    .displayable_name
9484                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
9485                fidl::decode!(
9486                    fidl::encoding::BoundedString<255>,
9487                    D,
9488                    val_ref,
9489                    decoder,
9490                    inner_offset,
9491                    inner_depth
9492                )?;
9493                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9494                {
9495                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9496                }
9497                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9498                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9499                }
9500            }
9501
9502            next_offset += envelope_size;
9503            _next_ordinal_to_read += 1;
9504            if next_offset >= end_offset {
9505                return Ok(());
9506            }
9507
9508            // Decode unknown envelopes for gaps in ordinals.
9509            while _next_ordinal_to_read < 6 {
9510                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9511                _next_ordinal_to_read += 1;
9512                next_offset += envelope_size;
9513            }
9514
9515            let next_out_of_line = decoder.next_out_of_line();
9516            let handles_before = decoder.remaining_handles();
9517            if let Some((inlined, num_bytes, num_handles)) =
9518                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9519            {
9520                let member_inline_size =
9521                    <PlayerFeatureBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9522                if inlined != (member_inline_size <= 4) {
9523                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9524                }
9525                let inner_offset;
9526                let mut inner_depth = depth.clone();
9527                if inlined {
9528                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9529                    inner_offset = next_offset;
9530                } else {
9531                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9532                    inner_depth.increment()?;
9533                }
9534                let val_ref =
9535                    self.feature_bits.get_or_insert_with(|| fidl::new_empty!(PlayerFeatureBits, D));
9536                fidl::decode!(PlayerFeatureBits, D, val_ref, decoder, inner_offset, inner_depth)?;
9537                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9538                {
9539                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9540                }
9541                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9542                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9543                }
9544            }
9545
9546            next_offset += envelope_size;
9547            _next_ordinal_to_read += 1;
9548            if next_offset >= end_offset {
9549                return Ok(());
9550            }
9551
9552            // Decode unknown envelopes for gaps in ordinals.
9553            while _next_ordinal_to_read < 7 {
9554                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9555                _next_ordinal_to_read += 1;
9556                next_offset += envelope_size;
9557            }
9558
9559            let next_out_of_line = decoder.next_out_of_line();
9560            let handles_before = decoder.remaining_handles();
9561            if let Some((inlined, num_bytes, num_handles)) =
9562                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9563            {
9564                let member_inline_size =
9565                    <PlayerFeatureBitsExt as fidl::encoding::TypeMarker>::inline_size(
9566                        decoder.context,
9567                    );
9568                if inlined != (member_inline_size <= 4) {
9569                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9570                }
9571                let inner_offset;
9572                let mut inner_depth = depth.clone();
9573                if inlined {
9574                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9575                    inner_offset = next_offset;
9576                } else {
9577                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9578                    inner_depth.increment()?;
9579                }
9580                let val_ref = self
9581                    .feature_bits_ext
9582                    .get_or_insert_with(|| fidl::new_empty!(PlayerFeatureBitsExt, D));
9583                fidl::decode!(
9584                    PlayerFeatureBitsExt,
9585                    D,
9586                    val_ref,
9587                    decoder,
9588                    inner_offset,
9589                    inner_depth
9590                )?;
9591                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9592                {
9593                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9594                }
9595                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9596                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9597                }
9598            }
9599
9600            next_offset += envelope_size;
9601
9602            // Decode the remaining unknown envelopes.
9603            while next_offset < end_offset {
9604                _next_ordinal_to_read += 1;
9605                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9606                next_offset += envelope_size;
9607            }
9608
9609            Ok(())
9610        }
9611    }
9612
9613    impl Notification {
9614        #[inline(always)]
9615        fn max_ordinal_present(&self) -> u64 {
9616            if let Some(_) = self.addressed_player {
9617                return 11;
9618            }
9619            if let Some(_) = self.available_players_changed {
9620                return 10;
9621            }
9622            if let Some(_) = self.device_connected {
9623                return 9;
9624            }
9625            if let Some(_) = self.volume {
9626                return 8;
9627            }
9628            if let Some(_) = self.player_id {
9629                return 7;
9630            }
9631            if let Some(_) = self.application_settings {
9632                return 6;
9633            }
9634            if let Some(_) = self.system_status {
9635                return 5;
9636            }
9637            if let Some(_) = self.battery_status {
9638                return 4;
9639            }
9640            if let Some(_) = self.pos {
9641                return 3;
9642            }
9643            if let Some(_) = self.track_id {
9644                return 2;
9645            }
9646            if let Some(_) = self.status {
9647                return 1;
9648            }
9649            0
9650        }
9651    }
9652
9653    impl fidl::encoding::ValueTypeMarker for Notification {
9654        type Borrowed<'a> = &'a Self;
9655        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9656            value
9657        }
9658    }
9659
9660    unsafe impl fidl::encoding::TypeMarker for Notification {
9661        type Owned = Self;
9662
9663        #[inline(always)]
9664        fn inline_align(_context: fidl::encoding::Context) -> usize {
9665            8
9666        }
9667
9668        #[inline(always)]
9669        fn inline_size(_context: fidl::encoding::Context) -> usize {
9670            16
9671        }
9672    }
9673
9674    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Notification, D>
9675        for &Notification
9676    {
9677        unsafe fn encode(
9678            self,
9679            encoder: &mut fidl::encoding::Encoder<'_, D>,
9680            offset: usize,
9681            mut depth: fidl::encoding::Depth,
9682        ) -> fidl::Result<()> {
9683            encoder.debug_check_bounds::<Notification>(offset);
9684            // Vector header
9685            let max_ordinal: u64 = self.max_ordinal_present();
9686            encoder.write_num(max_ordinal, offset);
9687            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9688            // Calling encoder.out_of_line_offset(0) is not allowed.
9689            if max_ordinal == 0 {
9690                return Ok(());
9691            }
9692            depth.increment()?;
9693            let envelope_size = 8;
9694            let bytes_len = max_ordinal as usize * envelope_size;
9695            #[allow(unused_variables)]
9696            let offset = encoder.out_of_line_offset(bytes_len);
9697            let mut _prev_end_offset: usize = 0;
9698            if 1 > max_ordinal {
9699                return Ok(());
9700            }
9701
9702            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9703            // are envelope_size bytes.
9704            let cur_offset: usize = (1 - 1) * envelope_size;
9705
9706            // Zero reserved fields.
9707            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9708
9709            // Safety:
9710            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9711            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9712            //   envelope_size bytes, there is always sufficient room.
9713            fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
9714                self.status
9715                    .as_ref()
9716                    .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
9717                encoder,
9718                offset + cur_offset,
9719                depth,
9720            )?;
9721
9722            _prev_end_offset = cur_offset + envelope_size;
9723            if 2 > max_ordinal {
9724                return Ok(());
9725            }
9726
9727            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9728            // are envelope_size bytes.
9729            let cur_offset: usize = (2 - 1) * envelope_size;
9730
9731            // Zero reserved fields.
9732            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9733
9734            // Safety:
9735            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9736            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9737            //   envelope_size bytes, there is always sufficient room.
9738            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9739                self.track_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9740                encoder,
9741                offset + cur_offset,
9742                depth,
9743            )?;
9744
9745            _prev_end_offset = cur_offset + envelope_size;
9746            if 3 > max_ordinal {
9747                return Ok(());
9748            }
9749
9750            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9751            // are envelope_size bytes.
9752            let cur_offset: usize = (3 - 1) * envelope_size;
9753
9754            // Zero reserved fields.
9755            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9756
9757            // Safety:
9758            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9759            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9760            //   envelope_size bytes, there is always sufficient room.
9761            fidl::encoding::encode_in_envelope_optional::<u32, D>(
9762                self.pos.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9763                encoder,
9764                offset + cur_offset,
9765                depth,
9766            )?;
9767
9768            _prev_end_offset = cur_offset + envelope_size;
9769            if 4 > max_ordinal {
9770                return Ok(());
9771            }
9772
9773            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9774            // are envelope_size bytes.
9775            let cur_offset: usize = (4 - 1) * envelope_size;
9776
9777            // Zero reserved fields.
9778            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9779
9780            // Safety:
9781            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9782            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9783            //   envelope_size bytes, there is always sufficient room.
9784            fidl::encoding::encode_in_envelope_optional::<BatteryStatus, D>(
9785                self.battery_status
9786                    .as_ref()
9787                    .map(<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow),
9788                encoder,
9789                offset + cur_offset,
9790                depth,
9791            )?;
9792
9793            _prev_end_offset = cur_offset + envelope_size;
9794            if 5 > max_ordinal {
9795                return Ok(());
9796            }
9797
9798            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9799            // are envelope_size bytes.
9800            let cur_offset: usize = (5 - 1) * envelope_size;
9801
9802            // Zero reserved fields.
9803            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9804
9805            // Safety:
9806            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9807            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9808            //   envelope_size bytes, there is always sufficient room.
9809            fidl::encoding::encode_in_envelope_optional::<SystemStatus, D>(
9810                self.system_status
9811                    .as_ref()
9812                    .map(<SystemStatus as fidl::encoding::ValueTypeMarker>::borrow),
9813                encoder,
9814                offset + cur_offset,
9815                depth,
9816            )?;
9817
9818            _prev_end_offset = cur_offset + envelope_size;
9819            if 6 > max_ordinal {
9820                return Ok(());
9821            }
9822
9823            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9824            // are envelope_size bytes.
9825            let cur_offset: usize = (6 - 1) * envelope_size;
9826
9827            // Zero reserved fields.
9828            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9829
9830            // Safety:
9831            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9832            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9833            //   envelope_size bytes, there is always sufficient room.
9834            fidl::encoding::encode_in_envelope_optional::<PlayerApplicationSettings, D>(
9835                self.application_settings
9836                    .as_ref()
9837                    .map(<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow),
9838                encoder,
9839                offset + cur_offset,
9840                depth,
9841            )?;
9842
9843            _prev_end_offset = cur_offset + envelope_size;
9844            if 7 > max_ordinal {
9845                return Ok(());
9846            }
9847
9848            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9849            // are envelope_size bytes.
9850            let cur_offset: usize = (7 - 1) * envelope_size;
9851
9852            // Zero reserved fields.
9853            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9854
9855            // Safety:
9856            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9857            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9858            //   envelope_size bytes, there is always sufficient room.
9859            fidl::encoding::encode_in_envelope_optional::<u16, D>(
9860                self.player_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9861                encoder,
9862                offset + cur_offset,
9863                depth,
9864            )?;
9865
9866            _prev_end_offset = cur_offset + envelope_size;
9867            if 8 > max_ordinal {
9868                return Ok(());
9869            }
9870
9871            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9872            // are envelope_size bytes.
9873            let cur_offset: usize = (8 - 1) * envelope_size;
9874
9875            // Zero reserved fields.
9876            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9877
9878            // Safety:
9879            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9880            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9881            //   envelope_size bytes, there is always sufficient room.
9882            fidl::encoding::encode_in_envelope_optional::<u8, D>(
9883                self.volume.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
9884                encoder,
9885                offset + cur_offset,
9886                depth,
9887            )?;
9888
9889            _prev_end_offset = cur_offset + envelope_size;
9890            if 9 > max_ordinal {
9891                return Ok(());
9892            }
9893
9894            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9895            // are envelope_size bytes.
9896            let cur_offset: usize = (9 - 1) * envelope_size;
9897
9898            // Zero reserved fields.
9899            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9900
9901            // Safety:
9902            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9903            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9904            //   envelope_size bytes, there is always sufficient room.
9905            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9906                self.device_connected
9907                    .as_ref()
9908                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9909                encoder,
9910                offset + cur_offset,
9911                depth,
9912            )?;
9913
9914            _prev_end_offset = cur_offset + envelope_size;
9915            if 10 > max_ordinal {
9916                return Ok(());
9917            }
9918
9919            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9920            // are envelope_size bytes.
9921            let cur_offset: usize = (10 - 1) * envelope_size;
9922
9923            // Zero reserved fields.
9924            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9925
9926            // Safety:
9927            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9928            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9929            //   envelope_size bytes, there is always sufficient room.
9930            fidl::encoding::encode_in_envelope_optional::<bool, D>(
9931                self.available_players_changed
9932                    .as_ref()
9933                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9934                encoder,
9935                offset + cur_offset,
9936                depth,
9937            )?;
9938
9939            _prev_end_offset = cur_offset + envelope_size;
9940            if 11 > max_ordinal {
9941                return Ok(());
9942            }
9943
9944            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9945            // are envelope_size bytes.
9946            let cur_offset: usize = (11 - 1) * envelope_size;
9947
9948            // Zero reserved fields.
9949            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9950
9951            // Safety:
9952            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9953            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9954            //   envelope_size bytes, there is always sufficient room.
9955            fidl::encoding::encode_in_envelope_optional::<u16, D>(
9956                self.addressed_player
9957                    .as_ref()
9958                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9959                encoder,
9960                offset + cur_offset,
9961                depth,
9962            )?;
9963
9964            _prev_end_offset = cur_offset + envelope_size;
9965
9966            Ok(())
9967        }
9968    }
9969
9970    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notification {
9971        #[inline(always)]
9972        fn new_empty() -> Self {
9973            Self::default()
9974        }
9975
9976        unsafe fn decode(
9977            &mut self,
9978            decoder: &mut fidl::encoding::Decoder<'_, D>,
9979            offset: usize,
9980            mut depth: fidl::encoding::Depth,
9981        ) -> fidl::Result<()> {
9982            decoder.debug_check_bounds::<Self>(offset);
9983            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9984                None => return Err(fidl::Error::NotNullable),
9985                Some(len) => len,
9986            };
9987            // Calling decoder.out_of_line_offset(0) is not allowed.
9988            if len == 0 {
9989                return Ok(());
9990            };
9991            depth.increment()?;
9992            let envelope_size = 8;
9993            let bytes_len = len * envelope_size;
9994            let offset = decoder.out_of_line_offset(bytes_len)?;
9995            // Decode the envelope for each type.
9996            let mut _next_ordinal_to_read = 0;
9997            let mut next_offset = offset;
9998            let end_offset = offset + bytes_len;
9999            _next_ordinal_to_read += 1;
10000            if next_offset >= end_offset {
10001                return Ok(());
10002            }
10003
10004            // Decode unknown envelopes for gaps in ordinals.
10005            while _next_ordinal_to_read < 1 {
10006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10007                _next_ordinal_to_read += 1;
10008                next_offset += envelope_size;
10009            }
10010
10011            let next_out_of_line = decoder.next_out_of_line();
10012            let handles_before = decoder.remaining_handles();
10013            if let Some((inlined, num_bytes, num_handles)) =
10014                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10015            {
10016                let member_inline_size =
10017                    <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10018                if inlined != (member_inline_size <= 4) {
10019                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10020                }
10021                let inner_offset;
10022                let mut inner_depth = depth.clone();
10023                if inlined {
10024                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10025                    inner_offset = next_offset;
10026                } else {
10027                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10028                    inner_depth.increment()?;
10029                }
10030                let val_ref =
10031                    self.status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
10032                fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10033                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10034                {
10035                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10036                }
10037                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10038                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10039                }
10040            }
10041
10042            next_offset += envelope_size;
10043            _next_ordinal_to_read += 1;
10044            if next_offset >= end_offset {
10045                return Ok(());
10046            }
10047
10048            // Decode unknown envelopes for gaps in ordinals.
10049            while _next_ordinal_to_read < 2 {
10050                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10051                _next_ordinal_to_read += 1;
10052                next_offset += envelope_size;
10053            }
10054
10055            let next_out_of_line = decoder.next_out_of_line();
10056            let handles_before = decoder.remaining_handles();
10057            if let Some((inlined, num_bytes, num_handles)) =
10058                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10059            {
10060                let member_inline_size =
10061                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10062                if inlined != (member_inline_size <= 4) {
10063                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10064                }
10065                let inner_offset;
10066                let mut inner_depth = depth.clone();
10067                if inlined {
10068                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10069                    inner_offset = next_offset;
10070                } else {
10071                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10072                    inner_depth.increment()?;
10073                }
10074                let val_ref = self.track_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
10075                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10076                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10077                {
10078                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10079                }
10080                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10081                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10082                }
10083            }
10084
10085            next_offset += envelope_size;
10086            _next_ordinal_to_read += 1;
10087            if next_offset >= end_offset {
10088                return Ok(());
10089            }
10090
10091            // Decode unknown envelopes for gaps in ordinals.
10092            while _next_ordinal_to_read < 3 {
10093                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10094                _next_ordinal_to_read += 1;
10095                next_offset += envelope_size;
10096            }
10097
10098            let next_out_of_line = decoder.next_out_of_line();
10099            let handles_before = decoder.remaining_handles();
10100            if let Some((inlined, num_bytes, num_handles)) =
10101                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10102            {
10103                let member_inline_size =
10104                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10105                if inlined != (member_inline_size <= 4) {
10106                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10107                }
10108                let inner_offset;
10109                let mut inner_depth = depth.clone();
10110                if inlined {
10111                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10112                    inner_offset = next_offset;
10113                } else {
10114                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10115                    inner_depth.increment()?;
10116                }
10117                let val_ref = self.pos.get_or_insert_with(|| fidl::new_empty!(u32, D));
10118                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10119                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10120                {
10121                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10122                }
10123                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10124                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10125                }
10126            }
10127
10128            next_offset += envelope_size;
10129            _next_ordinal_to_read += 1;
10130            if next_offset >= end_offset {
10131                return Ok(());
10132            }
10133
10134            // Decode unknown envelopes for gaps in ordinals.
10135            while _next_ordinal_to_read < 4 {
10136                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10137                _next_ordinal_to_read += 1;
10138                next_offset += envelope_size;
10139            }
10140
10141            let next_out_of_line = decoder.next_out_of_line();
10142            let handles_before = decoder.remaining_handles();
10143            if let Some((inlined, num_bytes, num_handles)) =
10144                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10145            {
10146                let member_inline_size =
10147                    <BatteryStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10148                if inlined != (member_inline_size <= 4) {
10149                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10150                }
10151                let inner_offset;
10152                let mut inner_depth = depth.clone();
10153                if inlined {
10154                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10155                    inner_offset = next_offset;
10156                } else {
10157                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10158                    inner_depth.increment()?;
10159                }
10160                let val_ref =
10161                    self.battery_status.get_or_insert_with(|| fidl::new_empty!(BatteryStatus, D));
10162                fidl::decode!(BatteryStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10164                {
10165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10166                }
10167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10169                }
10170            }
10171
10172            next_offset += envelope_size;
10173            _next_ordinal_to_read += 1;
10174            if next_offset >= end_offset {
10175                return Ok(());
10176            }
10177
10178            // Decode unknown envelopes for gaps in ordinals.
10179            while _next_ordinal_to_read < 5 {
10180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10181                _next_ordinal_to_read += 1;
10182                next_offset += envelope_size;
10183            }
10184
10185            let next_out_of_line = decoder.next_out_of_line();
10186            let handles_before = decoder.remaining_handles();
10187            if let Some((inlined, num_bytes, num_handles)) =
10188                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10189            {
10190                let member_inline_size =
10191                    <SystemStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10192                if inlined != (member_inline_size <= 4) {
10193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10194                }
10195                let inner_offset;
10196                let mut inner_depth = depth.clone();
10197                if inlined {
10198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10199                    inner_offset = next_offset;
10200                } else {
10201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10202                    inner_depth.increment()?;
10203                }
10204                let val_ref =
10205                    self.system_status.get_or_insert_with(|| fidl::new_empty!(SystemStatus, D));
10206                fidl::decode!(SystemStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10207                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10208                {
10209                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10210                }
10211                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10212                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10213                }
10214            }
10215
10216            next_offset += envelope_size;
10217            _next_ordinal_to_read += 1;
10218            if next_offset >= end_offset {
10219                return Ok(());
10220            }
10221
10222            // Decode unknown envelopes for gaps in ordinals.
10223            while _next_ordinal_to_read < 6 {
10224                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10225                _next_ordinal_to_read += 1;
10226                next_offset += envelope_size;
10227            }
10228
10229            let next_out_of_line = decoder.next_out_of_line();
10230            let handles_before = decoder.remaining_handles();
10231            if let Some((inlined, num_bytes, num_handles)) =
10232                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10233            {
10234                let member_inline_size =
10235                    <PlayerApplicationSettings as fidl::encoding::TypeMarker>::inline_size(
10236                        decoder.context,
10237                    );
10238                if inlined != (member_inline_size <= 4) {
10239                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10240                }
10241                let inner_offset;
10242                let mut inner_depth = depth.clone();
10243                if inlined {
10244                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10245                    inner_offset = next_offset;
10246                } else {
10247                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10248                    inner_depth.increment()?;
10249                }
10250                let val_ref = self
10251                    .application_settings
10252                    .get_or_insert_with(|| fidl::new_empty!(PlayerApplicationSettings, D));
10253                fidl::decode!(
10254                    PlayerApplicationSettings,
10255                    D,
10256                    val_ref,
10257                    decoder,
10258                    inner_offset,
10259                    inner_depth
10260                )?;
10261                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10262                {
10263                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10264                }
10265                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10266                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10267                }
10268            }
10269
10270            next_offset += envelope_size;
10271            _next_ordinal_to_read += 1;
10272            if next_offset >= end_offset {
10273                return Ok(());
10274            }
10275
10276            // Decode unknown envelopes for gaps in ordinals.
10277            while _next_ordinal_to_read < 7 {
10278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10279                _next_ordinal_to_read += 1;
10280                next_offset += envelope_size;
10281            }
10282
10283            let next_out_of_line = decoder.next_out_of_line();
10284            let handles_before = decoder.remaining_handles();
10285            if let Some((inlined, num_bytes, num_handles)) =
10286                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10287            {
10288                let member_inline_size =
10289                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10290                if inlined != (member_inline_size <= 4) {
10291                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10292                }
10293                let inner_offset;
10294                let mut inner_depth = depth.clone();
10295                if inlined {
10296                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10297                    inner_offset = next_offset;
10298                } else {
10299                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10300                    inner_depth.increment()?;
10301                }
10302                let val_ref = self.player_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10303                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10304                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10305                {
10306                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10307                }
10308                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10309                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10310                }
10311            }
10312
10313            next_offset += envelope_size;
10314            _next_ordinal_to_read += 1;
10315            if next_offset >= end_offset {
10316                return Ok(());
10317            }
10318
10319            // Decode unknown envelopes for gaps in ordinals.
10320            while _next_ordinal_to_read < 8 {
10321                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10322                _next_ordinal_to_read += 1;
10323                next_offset += envelope_size;
10324            }
10325
10326            let next_out_of_line = decoder.next_out_of_line();
10327            let handles_before = decoder.remaining_handles();
10328            if let Some((inlined, num_bytes, num_handles)) =
10329                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10330            {
10331                let member_inline_size =
10332                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10333                if inlined != (member_inline_size <= 4) {
10334                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10335                }
10336                let inner_offset;
10337                let mut inner_depth = depth.clone();
10338                if inlined {
10339                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10340                    inner_offset = next_offset;
10341                } else {
10342                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10343                    inner_depth.increment()?;
10344                }
10345                let val_ref = self.volume.get_or_insert_with(|| fidl::new_empty!(u8, D));
10346                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
10347                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10348                {
10349                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10350                }
10351                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10352                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10353                }
10354            }
10355
10356            next_offset += envelope_size;
10357            _next_ordinal_to_read += 1;
10358            if next_offset >= end_offset {
10359                return Ok(());
10360            }
10361
10362            // Decode unknown envelopes for gaps in ordinals.
10363            while _next_ordinal_to_read < 9 {
10364                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10365                _next_ordinal_to_read += 1;
10366                next_offset += envelope_size;
10367            }
10368
10369            let next_out_of_line = decoder.next_out_of_line();
10370            let handles_before = decoder.remaining_handles();
10371            if let Some((inlined, num_bytes, num_handles)) =
10372                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10373            {
10374                let member_inline_size =
10375                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10376                if inlined != (member_inline_size <= 4) {
10377                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10378                }
10379                let inner_offset;
10380                let mut inner_depth = depth.clone();
10381                if inlined {
10382                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10383                    inner_offset = next_offset;
10384                } else {
10385                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10386                    inner_depth.increment()?;
10387                }
10388                let val_ref =
10389                    self.device_connected.get_or_insert_with(|| fidl::new_empty!(bool, D));
10390                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10391                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10392                {
10393                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10394                }
10395                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10396                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10397                }
10398            }
10399
10400            next_offset += envelope_size;
10401            _next_ordinal_to_read += 1;
10402            if next_offset >= end_offset {
10403                return Ok(());
10404            }
10405
10406            // Decode unknown envelopes for gaps in ordinals.
10407            while _next_ordinal_to_read < 10 {
10408                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10409                _next_ordinal_to_read += 1;
10410                next_offset += envelope_size;
10411            }
10412
10413            let next_out_of_line = decoder.next_out_of_line();
10414            let handles_before = decoder.remaining_handles();
10415            if let Some((inlined, num_bytes, num_handles)) =
10416                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10417            {
10418                let member_inline_size =
10419                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10420                if inlined != (member_inline_size <= 4) {
10421                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10422                }
10423                let inner_offset;
10424                let mut inner_depth = depth.clone();
10425                if inlined {
10426                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10427                    inner_offset = next_offset;
10428                } else {
10429                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10430                    inner_depth.increment()?;
10431                }
10432                let val_ref =
10433                    self.available_players_changed.get_or_insert_with(|| fidl::new_empty!(bool, D));
10434                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10435                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10436                {
10437                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10438                }
10439                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10440                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10441                }
10442            }
10443
10444            next_offset += envelope_size;
10445            _next_ordinal_to_read += 1;
10446            if next_offset >= end_offset {
10447                return Ok(());
10448            }
10449
10450            // Decode unknown envelopes for gaps in ordinals.
10451            while _next_ordinal_to_read < 11 {
10452                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10453                _next_ordinal_to_read += 1;
10454                next_offset += envelope_size;
10455            }
10456
10457            let next_out_of_line = decoder.next_out_of_line();
10458            let handles_before = decoder.remaining_handles();
10459            if let Some((inlined, num_bytes, num_handles)) =
10460                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10461            {
10462                let member_inline_size =
10463                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10464                if inlined != (member_inline_size <= 4) {
10465                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10466                }
10467                let inner_offset;
10468                let mut inner_depth = depth.clone();
10469                if inlined {
10470                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10471                    inner_offset = next_offset;
10472                } else {
10473                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10474                    inner_depth.increment()?;
10475                }
10476                let val_ref = self.addressed_player.get_or_insert_with(|| fidl::new_empty!(u16, D));
10477                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10478                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10479                {
10480                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10481                }
10482                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10483                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10484                }
10485            }
10486
10487            next_offset += envelope_size;
10488
10489            // Decode the remaining unknown envelopes.
10490            while next_offset < end_offset {
10491                _next_ordinal_to_read += 1;
10492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10493                next_offset += envelope_size;
10494            }
10495
10496            Ok(())
10497        }
10498    }
10499
10500    impl PlayStatus {
10501        #[inline(always)]
10502        fn max_ordinal_present(&self) -> u64 {
10503            if let Some(_) = self.playback_status {
10504                return 3;
10505            }
10506            if let Some(_) = self.song_position {
10507                return 2;
10508            }
10509            if let Some(_) = self.song_length {
10510                return 1;
10511            }
10512            0
10513        }
10514    }
10515
10516    impl fidl::encoding::ValueTypeMarker for PlayStatus {
10517        type Borrowed<'a> = &'a Self;
10518        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10519            value
10520        }
10521    }
10522
10523    unsafe impl fidl::encoding::TypeMarker for PlayStatus {
10524        type Owned = Self;
10525
10526        #[inline(always)]
10527        fn inline_align(_context: fidl::encoding::Context) -> usize {
10528            8
10529        }
10530
10531        #[inline(always)]
10532        fn inline_size(_context: fidl::encoding::Context) -> usize {
10533            16
10534        }
10535    }
10536
10537    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PlayStatus, D>
10538        for &PlayStatus
10539    {
10540        unsafe fn encode(
10541            self,
10542            encoder: &mut fidl::encoding::Encoder<'_, D>,
10543            offset: usize,
10544            mut depth: fidl::encoding::Depth,
10545        ) -> fidl::Result<()> {
10546            encoder.debug_check_bounds::<PlayStatus>(offset);
10547            // Vector header
10548            let max_ordinal: u64 = self.max_ordinal_present();
10549            encoder.write_num(max_ordinal, offset);
10550            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10551            // Calling encoder.out_of_line_offset(0) is not allowed.
10552            if max_ordinal == 0 {
10553                return Ok(());
10554            }
10555            depth.increment()?;
10556            let envelope_size = 8;
10557            let bytes_len = max_ordinal as usize * envelope_size;
10558            #[allow(unused_variables)]
10559            let offset = encoder.out_of_line_offset(bytes_len);
10560            let mut _prev_end_offset: usize = 0;
10561            if 1 > max_ordinal {
10562                return Ok(());
10563            }
10564
10565            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10566            // are envelope_size bytes.
10567            let cur_offset: usize = (1 - 1) * envelope_size;
10568
10569            // Zero reserved fields.
10570            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10571
10572            // Safety:
10573            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10574            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10575            //   envelope_size bytes, there is always sufficient room.
10576            fidl::encoding::encode_in_envelope_optional::<u32, D>(
10577                self.song_length.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
10578                encoder,
10579                offset + cur_offset,
10580                depth,
10581            )?;
10582
10583            _prev_end_offset = cur_offset + envelope_size;
10584            if 2 > max_ordinal {
10585                return Ok(());
10586            }
10587
10588            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10589            // are envelope_size bytes.
10590            let cur_offset: usize = (2 - 1) * envelope_size;
10591
10592            // Zero reserved fields.
10593            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10594
10595            // Safety:
10596            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10597            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10598            //   envelope_size bytes, there is always sufficient room.
10599            fidl::encoding::encode_in_envelope_optional::<u32, D>(
10600                self.song_position.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
10601                encoder,
10602                offset + cur_offset,
10603                depth,
10604            )?;
10605
10606            _prev_end_offset = cur_offset + envelope_size;
10607            if 3 > max_ordinal {
10608                return Ok(());
10609            }
10610
10611            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10612            // are envelope_size bytes.
10613            let cur_offset: usize = (3 - 1) * envelope_size;
10614
10615            // Zero reserved fields.
10616            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10617
10618            // Safety:
10619            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10620            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10621            //   envelope_size bytes, there is always sufficient room.
10622            fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
10623                self.playback_status
10624                    .as_ref()
10625                    .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
10626                encoder,
10627                offset + cur_offset,
10628                depth,
10629            )?;
10630
10631            _prev_end_offset = cur_offset + envelope_size;
10632
10633            Ok(())
10634        }
10635    }
10636
10637    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayStatus {
10638        #[inline(always)]
10639        fn new_empty() -> Self {
10640            Self::default()
10641        }
10642
10643        unsafe fn decode(
10644            &mut self,
10645            decoder: &mut fidl::encoding::Decoder<'_, D>,
10646            offset: usize,
10647            mut depth: fidl::encoding::Depth,
10648        ) -> fidl::Result<()> {
10649            decoder.debug_check_bounds::<Self>(offset);
10650            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10651                None => return Err(fidl::Error::NotNullable),
10652                Some(len) => len,
10653            };
10654            // Calling decoder.out_of_line_offset(0) is not allowed.
10655            if len == 0 {
10656                return Ok(());
10657            };
10658            depth.increment()?;
10659            let envelope_size = 8;
10660            let bytes_len = len * envelope_size;
10661            let offset = decoder.out_of_line_offset(bytes_len)?;
10662            // Decode the envelope for each type.
10663            let mut _next_ordinal_to_read = 0;
10664            let mut next_offset = offset;
10665            let end_offset = offset + bytes_len;
10666            _next_ordinal_to_read += 1;
10667            if next_offset >= end_offset {
10668                return Ok(());
10669            }
10670
10671            // Decode unknown envelopes for gaps in ordinals.
10672            while _next_ordinal_to_read < 1 {
10673                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10674                _next_ordinal_to_read += 1;
10675                next_offset += envelope_size;
10676            }
10677
10678            let next_out_of_line = decoder.next_out_of_line();
10679            let handles_before = decoder.remaining_handles();
10680            if let Some((inlined, num_bytes, num_handles)) =
10681                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10682            {
10683                let member_inline_size =
10684                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10685                if inlined != (member_inline_size <= 4) {
10686                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10687                }
10688                let inner_offset;
10689                let mut inner_depth = depth.clone();
10690                if inlined {
10691                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10692                    inner_offset = next_offset;
10693                } else {
10694                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10695                    inner_depth.increment()?;
10696                }
10697                let val_ref = self.song_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
10698                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10699                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10700                {
10701                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10702                }
10703                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10704                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10705                }
10706            }
10707
10708            next_offset += envelope_size;
10709            _next_ordinal_to_read += 1;
10710            if next_offset >= end_offset {
10711                return Ok(());
10712            }
10713
10714            // Decode unknown envelopes for gaps in ordinals.
10715            while _next_ordinal_to_read < 2 {
10716                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10717                _next_ordinal_to_read += 1;
10718                next_offset += envelope_size;
10719            }
10720
10721            let next_out_of_line = decoder.next_out_of_line();
10722            let handles_before = decoder.remaining_handles();
10723            if let Some((inlined, num_bytes, num_handles)) =
10724                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10725            {
10726                let member_inline_size =
10727                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10728                if inlined != (member_inline_size <= 4) {
10729                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10730                }
10731                let inner_offset;
10732                let mut inner_depth = depth.clone();
10733                if inlined {
10734                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10735                    inner_offset = next_offset;
10736                } else {
10737                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10738                    inner_depth.increment()?;
10739                }
10740                let val_ref = self.song_position.get_or_insert_with(|| fidl::new_empty!(u32, D));
10741                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10742                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10743                {
10744                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10745                }
10746                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10747                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10748                }
10749            }
10750
10751            next_offset += envelope_size;
10752            _next_ordinal_to_read += 1;
10753            if next_offset >= end_offset {
10754                return Ok(());
10755            }
10756
10757            // Decode unknown envelopes for gaps in ordinals.
10758            while _next_ordinal_to_read < 3 {
10759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10760                _next_ordinal_to_read += 1;
10761                next_offset += envelope_size;
10762            }
10763
10764            let next_out_of_line = decoder.next_out_of_line();
10765            let handles_before = decoder.remaining_handles();
10766            if let Some((inlined, num_bytes, num_handles)) =
10767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10768            {
10769                let member_inline_size =
10770                    <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10771                if inlined != (member_inline_size <= 4) {
10772                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10773                }
10774                let inner_offset;
10775                let mut inner_depth = depth.clone();
10776                if inlined {
10777                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10778                    inner_offset = next_offset;
10779                } else {
10780                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10781                    inner_depth.increment()?;
10782                }
10783                let val_ref =
10784                    self.playback_status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
10785                fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10786                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10787                {
10788                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10789                }
10790                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10791                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10792                }
10793            }
10794
10795            next_offset += envelope_size;
10796
10797            // Decode the remaining unknown envelopes.
10798            while next_offset < end_offset {
10799                _next_ordinal_to_read += 1;
10800                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10801                next_offset += envelope_size;
10802            }
10803
10804            Ok(())
10805        }
10806    }
10807
10808    impl PlayerApplicationSettings {
10809        #[inline(always)]
10810        fn max_ordinal_present(&self) -> u64 {
10811            if let Some(_) = self.custom_settings {
10812                return 5;
10813            }
10814            if let Some(_) = self.scan_mode {
10815                return 4;
10816            }
10817            if let Some(_) = self.shuffle_mode {
10818                return 3;
10819            }
10820            if let Some(_) = self.repeat_status_mode {
10821                return 2;
10822            }
10823            if let Some(_) = self.equalizer {
10824                return 1;
10825            }
10826            0
10827        }
10828    }
10829
10830    impl fidl::encoding::ValueTypeMarker for PlayerApplicationSettings {
10831        type Borrowed<'a> = &'a Self;
10832        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10833            value
10834        }
10835    }
10836
10837    unsafe impl fidl::encoding::TypeMarker for PlayerApplicationSettings {
10838        type Owned = Self;
10839
10840        #[inline(always)]
10841        fn inline_align(_context: fidl::encoding::Context) -> usize {
10842            8
10843        }
10844
10845        #[inline(always)]
10846        fn inline_size(_context: fidl::encoding::Context) -> usize {
10847            16
10848        }
10849    }
10850
10851    unsafe impl<D: fidl::encoding::ResourceDialect>
10852        fidl::encoding::Encode<PlayerApplicationSettings, D> for &PlayerApplicationSettings
10853    {
10854        unsafe fn encode(
10855            self,
10856            encoder: &mut fidl::encoding::Encoder<'_, D>,
10857            offset: usize,
10858            mut depth: fidl::encoding::Depth,
10859        ) -> fidl::Result<()> {
10860            encoder.debug_check_bounds::<PlayerApplicationSettings>(offset);
10861            // Vector header
10862            let max_ordinal: u64 = self.max_ordinal_present();
10863            encoder.write_num(max_ordinal, offset);
10864            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10865            // Calling encoder.out_of_line_offset(0) is not allowed.
10866            if max_ordinal == 0 {
10867                return Ok(());
10868            }
10869            depth.increment()?;
10870            let envelope_size = 8;
10871            let bytes_len = max_ordinal as usize * envelope_size;
10872            #[allow(unused_variables)]
10873            let offset = encoder.out_of_line_offset(bytes_len);
10874            let mut _prev_end_offset: usize = 0;
10875            if 1 > max_ordinal {
10876                return Ok(());
10877            }
10878
10879            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10880            // are envelope_size bytes.
10881            let cur_offset: usize = (1 - 1) * envelope_size;
10882
10883            // Zero reserved fields.
10884            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10885
10886            // Safety:
10887            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10888            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10889            //   envelope_size bytes, there is always sufficient room.
10890            fidl::encoding::encode_in_envelope_optional::<Equalizer, D>(
10891                self.equalizer.as_ref().map(<Equalizer as fidl::encoding::ValueTypeMarker>::borrow),
10892                encoder,
10893                offset + cur_offset,
10894                depth,
10895            )?;
10896
10897            _prev_end_offset = cur_offset + envelope_size;
10898            if 2 > max_ordinal {
10899                return Ok(());
10900            }
10901
10902            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10903            // are envelope_size bytes.
10904            let cur_offset: usize = (2 - 1) * envelope_size;
10905
10906            // Zero reserved fields.
10907            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10908
10909            // Safety:
10910            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10911            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10912            //   envelope_size bytes, there is always sufficient room.
10913            fidl::encoding::encode_in_envelope_optional::<RepeatStatusMode, D>(
10914                self.repeat_status_mode
10915                    .as_ref()
10916                    .map(<RepeatStatusMode as fidl::encoding::ValueTypeMarker>::borrow),
10917                encoder,
10918                offset + cur_offset,
10919                depth,
10920            )?;
10921
10922            _prev_end_offset = cur_offset + envelope_size;
10923            if 3 > max_ordinal {
10924                return Ok(());
10925            }
10926
10927            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10928            // are envelope_size bytes.
10929            let cur_offset: usize = (3 - 1) * envelope_size;
10930
10931            // Zero reserved fields.
10932            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10933
10934            // Safety:
10935            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10936            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10937            //   envelope_size bytes, there is always sufficient room.
10938            fidl::encoding::encode_in_envelope_optional::<ShuffleMode, D>(
10939                self.shuffle_mode
10940                    .as_ref()
10941                    .map(<ShuffleMode as fidl::encoding::ValueTypeMarker>::borrow),
10942                encoder,
10943                offset + cur_offset,
10944                depth,
10945            )?;
10946
10947            _prev_end_offset = cur_offset + envelope_size;
10948            if 4 > max_ordinal {
10949                return Ok(());
10950            }
10951
10952            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10953            // are envelope_size bytes.
10954            let cur_offset: usize = (4 - 1) * envelope_size;
10955
10956            // Zero reserved fields.
10957            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10958
10959            // Safety:
10960            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10961            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10962            //   envelope_size bytes, there is always sufficient room.
10963            fidl::encoding::encode_in_envelope_optional::<ScanMode, D>(
10964                self.scan_mode.as_ref().map(<ScanMode as fidl::encoding::ValueTypeMarker>::borrow),
10965                encoder,
10966                offset + cur_offset,
10967                depth,
10968            )?;
10969
10970            _prev_end_offset = cur_offset + envelope_size;
10971            if 5 > max_ordinal {
10972                return Ok(());
10973            }
10974
10975            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10976            // are envelope_size bytes.
10977            let cur_offset: usize = (5 - 1) * envelope_size;
10978
10979            // Zero reserved fields.
10980            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10981
10982            // Safety:
10983            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10984            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10985            //   envelope_size bytes, there is always sufficient room.
10986            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D>(
10987            self.custom_settings.as_ref().map(<fidl::encoding::Vector<CustomPlayerApplicationSetting, 127> as fidl::encoding::ValueTypeMarker>::borrow),
10988            encoder, offset + cur_offset, depth
10989        )?;
10990
10991            _prev_end_offset = cur_offset + envelope_size;
10992
10993            Ok(())
10994        }
10995    }
10996
10997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10998        for PlayerApplicationSettings
10999    {
11000        #[inline(always)]
11001        fn new_empty() -> Self {
11002            Self::default()
11003        }
11004
11005        unsafe fn decode(
11006            &mut self,
11007            decoder: &mut fidl::encoding::Decoder<'_, D>,
11008            offset: usize,
11009            mut depth: fidl::encoding::Depth,
11010        ) -> fidl::Result<()> {
11011            decoder.debug_check_bounds::<Self>(offset);
11012            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11013                None => return Err(fidl::Error::NotNullable),
11014                Some(len) => len,
11015            };
11016            // Calling decoder.out_of_line_offset(0) is not allowed.
11017            if len == 0 {
11018                return Ok(());
11019            };
11020            depth.increment()?;
11021            let envelope_size = 8;
11022            let bytes_len = len * envelope_size;
11023            let offset = decoder.out_of_line_offset(bytes_len)?;
11024            // Decode the envelope for each type.
11025            let mut _next_ordinal_to_read = 0;
11026            let mut next_offset = offset;
11027            let end_offset = offset + bytes_len;
11028            _next_ordinal_to_read += 1;
11029            if next_offset >= end_offset {
11030                return Ok(());
11031            }
11032
11033            // Decode unknown envelopes for gaps in ordinals.
11034            while _next_ordinal_to_read < 1 {
11035                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11036                _next_ordinal_to_read += 1;
11037                next_offset += envelope_size;
11038            }
11039
11040            let next_out_of_line = decoder.next_out_of_line();
11041            let handles_before = decoder.remaining_handles();
11042            if let Some((inlined, num_bytes, num_handles)) =
11043                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11044            {
11045                let member_inline_size =
11046                    <Equalizer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11047                if inlined != (member_inline_size <= 4) {
11048                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11049                }
11050                let inner_offset;
11051                let mut inner_depth = depth.clone();
11052                if inlined {
11053                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11054                    inner_offset = next_offset;
11055                } else {
11056                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11057                    inner_depth.increment()?;
11058                }
11059                let val_ref = self.equalizer.get_or_insert_with(|| fidl::new_empty!(Equalizer, D));
11060                fidl::decode!(Equalizer, D, val_ref, decoder, inner_offset, inner_depth)?;
11061                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11062                {
11063                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11064                }
11065                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11066                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11067                }
11068            }
11069
11070            next_offset += envelope_size;
11071            _next_ordinal_to_read += 1;
11072            if next_offset >= end_offset {
11073                return Ok(());
11074            }
11075
11076            // Decode unknown envelopes for gaps in ordinals.
11077            while _next_ordinal_to_read < 2 {
11078                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11079                _next_ordinal_to_read += 1;
11080                next_offset += envelope_size;
11081            }
11082
11083            let next_out_of_line = decoder.next_out_of_line();
11084            let handles_before = decoder.remaining_handles();
11085            if let Some((inlined, num_bytes, num_handles)) =
11086                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11087            {
11088                let member_inline_size =
11089                    <RepeatStatusMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11090                if inlined != (member_inline_size <= 4) {
11091                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11092                }
11093                let inner_offset;
11094                let mut inner_depth = depth.clone();
11095                if inlined {
11096                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11097                    inner_offset = next_offset;
11098                } else {
11099                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11100                    inner_depth.increment()?;
11101                }
11102                let val_ref = self
11103                    .repeat_status_mode
11104                    .get_or_insert_with(|| fidl::new_empty!(RepeatStatusMode, D));
11105                fidl::decode!(RepeatStatusMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11106                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11107                {
11108                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11109                }
11110                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11111                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11112                }
11113            }
11114
11115            next_offset += envelope_size;
11116            _next_ordinal_to_read += 1;
11117            if next_offset >= end_offset {
11118                return Ok(());
11119            }
11120
11121            // Decode unknown envelopes for gaps in ordinals.
11122            while _next_ordinal_to_read < 3 {
11123                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11124                _next_ordinal_to_read += 1;
11125                next_offset += envelope_size;
11126            }
11127
11128            let next_out_of_line = decoder.next_out_of_line();
11129            let handles_before = decoder.remaining_handles();
11130            if let Some((inlined, num_bytes, num_handles)) =
11131                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11132            {
11133                let member_inline_size =
11134                    <ShuffleMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11135                if inlined != (member_inline_size <= 4) {
11136                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11137                }
11138                let inner_offset;
11139                let mut inner_depth = depth.clone();
11140                if inlined {
11141                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11142                    inner_offset = next_offset;
11143                } else {
11144                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11145                    inner_depth.increment()?;
11146                }
11147                let val_ref =
11148                    self.shuffle_mode.get_or_insert_with(|| fidl::new_empty!(ShuffleMode, D));
11149                fidl::decode!(ShuffleMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11151                {
11152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11153                }
11154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11156                }
11157            }
11158
11159            next_offset += envelope_size;
11160            _next_ordinal_to_read += 1;
11161            if next_offset >= end_offset {
11162                return Ok(());
11163            }
11164
11165            // Decode unknown envelopes for gaps in ordinals.
11166            while _next_ordinal_to_read < 4 {
11167                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11168                _next_ordinal_to_read += 1;
11169                next_offset += envelope_size;
11170            }
11171
11172            let next_out_of_line = decoder.next_out_of_line();
11173            let handles_before = decoder.remaining_handles();
11174            if let Some((inlined, num_bytes, num_handles)) =
11175                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11176            {
11177                let member_inline_size =
11178                    <ScanMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11179                if inlined != (member_inline_size <= 4) {
11180                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11181                }
11182                let inner_offset;
11183                let mut inner_depth = depth.clone();
11184                if inlined {
11185                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11186                    inner_offset = next_offset;
11187                } else {
11188                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11189                    inner_depth.increment()?;
11190                }
11191                let val_ref = self.scan_mode.get_or_insert_with(|| fidl::new_empty!(ScanMode, D));
11192                fidl::decode!(ScanMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11193                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11194                {
11195                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11196                }
11197                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11198                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11199                }
11200            }
11201
11202            next_offset += envelope_size;
11203            _next_ordinal_to_read += 1;
11204            if next_offset >= end_offset {
11205                return Ok(());
11206            }
11207
11208            // Decode unknown envelopes for gaps in ordinals.
11209            while _next_ordinal_to_read < 5 {
11210                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11211                _next_ordinal_to_read += 1;
11212                next_offset += envelope_size;
11213            }
11214
11215            let next_out_of_line = decoder.next_out_of_line();
11216            let handles_before = decoder.remaining_handles();
11217            if let Some((inlined, num_bytes, num_handles)) =
11218                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11219            {
11220                let member_inline_size = <fidl::encoding::Vector<
11221                    CustomPlayerApplicationSetting,
11222                    127,
11223                > as fidl::encoding::TypeMarker>::inline_size(
11224                    decoder.context
11225                );
11226                if inlined != (member_inline_size <= 4) {
11227                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11228                }
11229                let inner_offset;
11230                let mut inner_depth = depth.clone();
11231                if inlined {
11232                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11233                    inner_offset = next_offset;
11234                } else {
11235                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11236                    inner_depth.increment()?;
11237                }
11238                let val_ref =
11239                self.custom_settings.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D));
11240                fidl::decode!(fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
11241                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11242                {
11243                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11244                }
11245                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11246                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11247                }
11248            }
11249
11250            next_offset += envelope_size;
11251
11252            // Decode the remaining unknown envelopes.
11253            while next_offset < end_offset {
11254                _next_ordinal_to_read += 1;
11255                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11256                next_offset += envelope_size;
11257            }
11258
11259            Ok(())
11260        }
11261    }
11262
11263    impl fidl::encoding::ValueTypeMarker for AttributeRequestOption {
11264        type Borrowed<'a> = &'a Self;
11265        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11266            value
11267        }
11268    }
11269
11270    unsafe impl fidl::encoding::TypeMarker for AttributeRequestOption {
11271        type Owned = Self;
11272
11273        #[inline(always)]
11274        fn inline_align(_context: fidl::encoding::Context) -> usize {
11275            8
11276        }
11277
11278        #[inline(always)]
11279        fn inline_size(_context: fidl::encoding::Context) -> usize {
11280            16
11281        }
11282    }
11283
11284    unsafe impl<D: fidl::encoding::ResourceDialect>
11285        fidl::encoding::Encode<AttributeRequestOption, D> for &AttributeRequestOption
11286    {
11287        #[inline]
11288        unsafe fn encode(
11289            self,
11290            encoder: &mut fidl::encoding::Encoder<'_, D>,
11291            offset: usize,
11292            _depth: fidl::encoding::Depth,
11293        ) -> fidl::Result<()> {
11294            encoder.debug_check_bounds::<AttributeRequestOption>(offset);
11295            encoder.write_num::<u64>(self.ordinal(), offset);
11296            match self {
11297            AttributeRequestOption::GetAll(ref val) => {
11298                fidl::encoding::encode_in_envelope::<bool, D>(
11299                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
11300                    encoder, offset + 8, _depth
11301                )
11302            }
11303            AttributeRequestOption::AttributeList(ref val) => {
11304                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<MediaAttributeId, 8>, D>(
11305                    <fidl::encoding::Vector<MediaAttributeId, 8> as fidl::encoding::ValueTypeMarker>::borrow(val),
11306                    encoder, offset + 8, _depth
11307                )
11308            }
11309        }
11310        }
11311    }
11312
11313    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11314        for AttributeRequestOption
11315    {
11316        #[inline(always)]
11317        fn new_empty() -> Self {
11318            Self::GetAll(fidl::new_empty!(bool, D))
11319        }
11320
11321        #[inline]
11322        unsafe fn decode(
11323            &mut self,
11324            decoder: &mut fidl::encoding::Decoder<'_, D>,
11325            offset: usize,
11326            mut depth: fidl::encoding::Depth,
11327        ) -> fidl::Result<()> {
11328            decoder.debug_check_bounds::<Self>(offset);
11329            #[allow(unused_variables)]
11330            let next_out_of_line = decoder.next_out_of_line();
11331            let handles_before = decoder.remaining_handles();
11332            let (ordinal, inlined, num_bytes, num_handles) =
11333                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11334
11335            let member_inline_size = match ordinal {
11336            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11337            2 => <fidl::encoding::Vector<MediaAttributeId, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11338            _ => return Err(fidl::Error::UnknownUnionTag),
11339        };
11340
11341            if inlined != (member_inline_size <= 4) {
11342                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11343            }
11344            let _inner_offset;
11345            if inlined {
11346                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11347                _inner_offset = offset + 8;
11348            } else {
11349                depth.increment()?;
11350                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11351            }
11352            match ordinal {
11353                1 => {
11354                    #[allow(irrefutable_let_patterns)]
11355                    if let AttributeRequestOption::GetAll(_) = self {
11356                        // Do nothing, read the value into the object
11357                    } else {
11358                        // Initialize `self` to the right variant
11359                        *self = AttributeRequestOption::GetAll(fidl::new_empty!(bool, D));
11360                    }
11361                    #[allow(irrefutable_let_patterns)]
11362                    if let AttributeRequestOption::GetAll(ref mut val) = self {
11363                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
11364                    } else {
11365                        unreachable!()
11366                    }
11367                }
11368                2 => {
11369                    #[allow(irrefutable_let_patterns)]
11370                    if let AttributeRequestOption::AttributeList(_) = self {
11371                        // Do nothing, read the value into the object
11372                    } else {
11373                        // Initialize `self` to the right variant
11374                        *self = AttributeRequestOption::AttributeList(
11375                            fidl::new_empty!(fidl::encoding::Vector<MediaAttributeId, 8>, D),
11376                        );
11377                    }
11378                    #[allow(irrefutable_let_patterns)]
11379                    if let AttributeRequestOption::AttributeList(ref mut val) = self {
11380                        fidl::decode!(fidl::encoding::Vector<MediaAttributeId, 8>, D, val, decoder, _inner_offset, depth)?;
11381                    } else {
11382                        unreachable!()
11383                    }
11384                }
11385                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11386            }
11387            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11388                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11389            }
11390            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11391                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11392            }
11393            Ok(())
11394        }
11395    }
11396
11397    impl fidl::encoding::ValueTypeMarker for FileSystemItem {
11398        type Borrowed<'a> = &'a Self;
11399        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11400            value
11401        }
11402    }
11403
11404    unsafe impl fidl::encoding::TypeMarker for FileSystemItem {
11405        type Owned = Self;
11406
11407        #[inline(always)]
11408        fn inline_align(_context: fidl::encoding::Context) -> usize {
11409            8
11410        }
11411
11412        #[inline(always)]
11413        fn inline_size(_context: fidl::encoding::Context) -> usize {
11414            16
11415        }
11416    }
11417
11418    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileSystemItem, D>
11419        for &FileSystemItem
11420    {
11421        #[inline]
11422        unsafe fn encode(
11423            self,
11424            encoder: &mut fidl::encoding::Encoder<'_, D>,
11425            offset: usize,
11426            _depth: fidl::encoding::Depth,
11427        ) -> fidl::Result<()> {
11428            encoder.debug_check_bounds::<FileSystemItem>(offset);
11429            encoder.write_num::<u64>(self.ordinal(), offset);
11430            match self {
11431                FileSystemItem::Folder(ref val) => {
11432                    fidl::encoding::encode_in_envelope::<FolderItem, D>(
11433                        <FolderItem as fidl::encoding::ValueTypeMarker>::borrow(val),
11434                        encoder,
11435                        offset + 8,
11436                        _depth,
11437                    )
11438                }
11439                FileSystemItem::MediaElement(ref val) => {
11440                    fidl::encoding::encode_in_envelope::<MediaElementItem, D>(
11441                        <MediaElementItem as fidl::encoding::ValueTypeMarker>::borrow(val),
11442                        encoder,
11443                        offset + 8,
11444                        _depth,
11445                    )
11446                }
11447            }
11448        }
11449    }
11450
11451    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileSystemItem {
11452        #[inline(always)]
11453        fn new_empty() -> Self {
11454            Self::Folder(fidl::new_empty!(FolderItem, D))
11455        }
11456
11457        #[inline]
11458        unsafe fn decode(
11459            &mut self,
11460            decoder: &mut fidl::encoding::Decoder<'_, D>,
11461            offset: usize,
11462            mut depth: fidl::encoding::Depth,
11463        ) -> fidl::Result<()> {
11464            decoder.debug_check_bounds::<Self>(offset);
11465            #[allow(unused_variables)]
11466            let next_out_of_line = decoder.next_out_of_line();
11467            let handles_before = decoder.remaining_handles();
11468            let (ordinal, inlined, num_bytes, num_handles) =
11469                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11470
11471            let member_inline_size = match ordinal {
11472                1 => <FolderItem as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11473                2 => <MediaElementItem as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11474                _ => return Err(fidl::Error::UnknownUnionTag),
11475            };
11476
11477            if inlined != (member_inline_size <= 4) {
11478                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11479            }
11480            let _inner_offset;
11481            if inlined {
11482                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11483                _inner_offset = offset + 8;
11484            } else {
11485                depth.increment()?;
11486                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11487            }
11488            match ordinal {
11489                1 => {
11490                    #[allow(irrefutable_let_patterns)]
11491                    if let FileSystemItem::Folder(_) = self {
11492                        // Do nothing, read the value into the object
11493                    } else {
11494                        // Initialize `self` to the right variant
11495                        *self = FileSystemItem::Folder(fidl::new_empty!(FolderItem, D));
11496                    }
11497                    #[allow(irrefutable_let_patterns)]
11498                    if let FileSystemItem::Folder(ref mut val) = self {
11499                        fidl::decode!(FolderItem, D, val, decoder, _inner_offset, depth)?;
11500                    } else {
11501                        unreachable!()
11502                    }
11503                }
11504                2 => {
11505                    #[allow(irrefutable_let_patterns)]
11506                    if let FileSystemItem::MediaElement(_) = self {
11507                        // Do nothing, read the value into the object
11508                    } else {
11509                        // Initialize `self` to the right variant
11510                        *self = FileSystemItem::MediaElement(fidl::new_empty!(MediaElementItem, D));
11511                    }
11512                    #[allow(irrefutable_let_patterns)]
11513                    if let FileSystemItem::MediaElement(ref mut val) = self {
11514                        fidl::decode!(MediaElementItem, D, val, decoder, _inner_offset, depth)?;
11515                    } else {
11516                        unreachable!()
11517                    }
11518                }
11519                ordinal => panic!("unexpected ordinal {:?}", ordinal),
11520            }
11521            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11522                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11523            }
11524            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11525                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11526            }
11527            Ok(())
11528        }
11529    }
11530
11531    impl fidl::encoding::ValueTypeMarker for Path {
11532        type Borrowed<'a> = &'a Self;
11533        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11534            value
11535        }
11536    }
11537
11538    unsafe impl fidl::encoding::TypeMarker for Path {
11539        type Owned = Self;
11540
11541        #[inline(always)]
11542        fn inline_align(_context: fidl::encoding::Context) -> usize {
11543            8
11544        }
11545
11546        #[inline(always)]
11547        fn inline_size(_context: fidl::encoding::Context) -> usize {
11548            16
11549        }
11550    }
11551
11552    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Path, D> for &Path {
11553        #[inline]
11554        unsafe fn encode(
11555            self,
11556            encoder: &mut fidl::encoding::Encoder<'_, D>,
11557            offset: usize,
11558            _depth: fidl::encoding::Depth,
11559        ) -> fidl::Result<()> {
11560            encoder.debug_check_bounds::<Path>(offset);
11561            encoder.write_num::<u64>(self.ordinal(), offset);
11562            match self {
11563                Path::Parent(ref val) => fidl::encoding::encode_in_envelope::<Parent, D>(
11564                    <Parent as fidl::encoding::ValueTypeMarker>::borrow(val),
11565                    encoder,
11566                    offset + 8,
11567                    _depth,
11568                ),
11569                Path::ChildFolderUid(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
11570                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
11571                    encoder,
11572                    offset + 8,
11573                    _depth,
11574                ),
11575                Path::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
11576            }
11577        }
11578    }
11579
11580    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Path {
11581        #[inline(always)]
11582        fn new_empty() -> Self {
11583            Self::__SourceBreaking { unknown_ordinal: 0 }
11584        }
11585
11586        #[inline]
11587        unsafe fn decode(
11588            &mut self,
11589            decoder: &mut fidl::encoding::Decoder<'_, D>,
11590            offset: usize,
11591            mut depth: fidl::encoding::Depth,
11592        ) -> fidl::Result<()> {
11593            decoder.debug_check_bounds::<Self>(offset);
11594            #[allow(unused_variables)]
11595            let next_out_of_line = decoder.next_out_of_line();
11596            let handles_before = decoder.remaining_handles();
11597            let (ordinal, inlined, num_bytes, num_handles) =
11598                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11599
11600            let member_inline_size = match ordinal {
11601                1 => <Parent as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11602                2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11603                0 => return Err(fidl::Error::UnknownUnionTag),
11604                _ => num_bytes as usize,
11605            };
11606
11607            if inlined != (member_inline_size <= 4) {
11608                return Err(fidl::Error::InvalidInlineBitInEnvelope);
11609            }
11610            let _inner_offset;
11611            if inlined {
11612                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11613                _inner_offset = offset + 8;
11614            } else {
11615                depth.increment()?;
11616                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11617            }
11618            match ordinal {
11619                1 => {
11620                    #[allow(irrefutable_let_patterns)]
11621                    if let Path::Parent(_) = self {
11622                        // Do nothing, read the value into the object
11623                    } else {
11624                        // Initialize `self` to the right variant
11625                        *self = Path::Parent(fidl::new_empty!(Parent, D));
11626                    }
11627                    #[allow(irrefutable_let_patterns)]
11628                    if let Path::Parent(ref mut val) = self {
11629                        fidl::decode!(Parent, D, val, decoder, _inner_offset, depth)?;
11630                    } else {
11631                        unreachable!()
11632                    }
11633                }
11634                2 => {
11635                    #[allow(irrefutable_let_patterns)]
11636                    if let Path::ChildFolderUid(_) = self {
11637                        // Do nothing, read the value into the object
11638                    } else {
11639                        // Initialize `self` to the right variant
11640                        *self = Path::ChildFolderUid(fidl::new_empty!(u64, D));
11641                    }
11642                    #[allow(irrefutable_let_patterns)]
11643                    if let Path::ChildFolderUid(ref mut val) = self {
11644                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
11645                    } else {
11646                        unreachable!()
11647                    }
11648                }
11649                #[allow(deprecated)]
11650                ordinal => {
11651                    for _ in 0..num_handles {
11652                        decoder.drop_next_handle()?;
11653                    }
11654                    *self = Path::__SourceBreaking { unknown_ordinal: ordinal };
11655                }
11656            }
11657            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11658                return Err(fidl::Error::InvalidNumBytesInEnvelope);
11659            }
11660            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11661                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11662            }
11663            Ok(())
11664        }
11665    }
11666}