fidl_fuchsia_diagnostics__common/
fidl_fuchsia_diagnostics__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const COMPONENT_URL_ARG_NAME: &str = "$__url";
12
13/// The size 64 was chosen because entries in batches are handles to
14/// VMOs and there is a limit of 64 handles per fidl message.
15pub const MAXIMUM_ENTRIES_PER_BATCH: u16 = 64;
16
17///  The size bound of 1024 is a reasonably low size restriction that meets most
18///  canonical selectors we've ecountered.
19pub const MAXIMUM_RAW_SELECTOR_LENGTH: u16 = 1024;
20
21pub const MAX_DATA_HIERARCHY_DEPTH: u16 = 100;
22
23/// Max number of LogInterestSelectors that can be specified via a listener.
24pub const MAX_LOG_SELECTORS: u8 = 64;
25
26pub const MAX_MONIKER_SEGMENTS: u16 = 25;
27
28pub const MAX_STRING_SELECTOR_LENGTH: u16 = 1024;
29
30pub const MONIKER_ARG_NAME: &str = "$__moniker";
31
32pub const ROLLED_OUT_ARG_NAME: &str = "$__rolled_out";
33
34#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
35#[repr(u8)]
36pub enum DataType {
37    /// Complete inspect hierarchies on the system.
38    Inspect = 1,
39    /// Log streams on the system.
40    Logs = 3,
41}
42
43impl DataType {
44    #[inline]
45    pub fn from_primitive(prim: u8) -> Option<Self> {
46        match prim {
47            1 => Some(Self::Inspect),
48            3 => Some(Self::Logs),
49            _ => None,
50        }
51    }
52
53    #[inline]
54    pub const fn into_primitive(self) -> u8 {
55        self as u8
56    }
57}
58
59/// Enum used to specify the output format for
60/// Reader results.
61#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
62#[repr(u32)]
63pub enum Format {
64    /// Dump read results per the Diagnostics Json
65    /// Schema specifications.
66    Json = 1,
67    /// Dump read results per the Iquery text specifications.
68    Text = 2,
69    /// Dump read results per the Diagnostics CBOR
70    /// Schema specifications.
71    Cbor = 3,
72    /// Dump read results per the Diagnostics FXT
73    /// Schema specifications. This is only supported
74    /// for logs.
75    Fxt = 4,
76}
77
78impl Format {
79    #[inline]
80    pub fn from_primitive(prim: u32) -> Option<Self> {
81        match prim {
82            1 => Some(Self::Json),
83            2 => Some(Self::Text),
84            3 => Some(Self::Cbor),
85            4 => Some(Self::Fxt),
86            _ => None,
87        }
88    }
89
90    #[inline]
91    pub const fn into_primitive(self) -> u32 {
92        self as u32
93    }
94}
95
96/// Enum describing the potential failure states of the streaming protocol when serving results
97/// to the client over the result iterator.
98#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
99#[repr(u32)]
100pub enum ReaderError {
101    Io = 1,
102}
103
104impl ReaderError {
105    #[inline]
106    pub fn from_primitive(prim: u32) -> Option<Self> {
107        match prim {
108            1 => Some(Self::Io),
109            _ => None,
110        }
111    }
112
113    #[inline]
114    pub const fn into_primitive(self) -> u32 {
115        self as u32
116    }
117}
118
119/// The severity of a given record.
120#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
121#[repr(u8)]
122pub enum Severity {
123    /// Trace records include detailed information about program execution.
124    Trace = 16,
125    /// Debug records include development-facing information about program execution.
126    Debug = 32,
127    /// Info records include general information about program execution. (default)
128    Info = 48,
129    /// Warning records include information about potentially problematic operations.
130    Warn = 64,
131    /// Error records include information about failed operations.
132    Error = 80,
133    /// Fatal records convey information about operations which cause a program's termination.
134    Fatal = 96,
135}
136
137impl Severity {
138    #[inline]
139    pub fn from_primitive(prim: u8) -> Option<Self> {
140        match prim {
141            16 => Some(Self::Trace),
142            32 => Some(Self::Debug),
143            48 => Some(Self::Info),
144            64 => Some(Self::Warn),
145            80 => Some(Self::Error),
146            96 => Some(Self::Fatal),
147            _ => None,
148        }
149    }
150
151    #[inline]
152    pub const fn into_primitive(self) -> u8 {
153        self as u8
154    }
155}
156
157/// Enum specifying the modes by which a user can connect to and stream diagnostics metrics.
158#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
159#[repr(u8)]
160pub enum StreamMode {
161    /// The stream will serve a snapshot of the diagnostics data at the time of
162    /// connection, then end.
163    Snapshot = 1,
164    /// The stream will serve a snapshot of the diagnostics data at the time of
165    /// connection, then subsequent calls to the stream will hang until
166    /// new diagnostics data is available.
167    SnapshotThenSubscribe = 2,
168    /// Calls to the stream will hang until new diagnostics data is available. Between calls to
169    /// the stream, newly arrived data is buffered.
170    Subscribe = 3,
171}
172
173impl StreamMode {
174    #[inline]
175    pub fn from_primitive(prim: u8) -> Option<Self> {
176        match prim {
177            1 => Some(Self::Snapshot),
178            2 => Some(Self::SnapshotThenSubscribe),
179            3 => Some(Self::Subscribe),
180            _ => None,
181        }
182    }
183
184    #[inline]
185    pub const fn into_primitive(self) -> u8 {
186        self as u8
187    }
188}
189
190#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
191pub struct All;
192
193impl fidl::Persistable for All {}
194
195#[derive(Clone, Debug, PartialEq)]
196pub struct LogInterestSelector {
197    /// Matches the components for which the interest will be requested.
198    pub selector: ComponentSelector,
199    /// The interest level that will be sent to components matching the selector.
200    pub interest: fidl_fuchsia_diagnostics_types__common::Interest,
201}
202
203impl fidl::Persistable for LogInterestSelector {}
204
205#[derive(Clone, Debug, PartialEq)]
206pub struct LogSettingsRegisterInterestRequest {
207    pub selectors: Vec<LogInterestSelector>,
208}
209
210impl fidl::Persistable for LogSettingsRegisterInterestRequest {}
211
212#[derive(Clone, Debug, PartialEq)]
213pub struct LogSettingsSetInterestRequest {
214    pub selectors: Vec<LogInterestSelector>,
215}
216
217impl fidl::Persistable for LogSettingsSetInterestRequest {}
218
219/// A selector defining a set of nodes to match, and on those matched nodes a set of named
220/// properties to match.
221#[derive(Clone, Debug, PartialEq)]
222pub struct PropertySelector {
223    /// A vector of StringSelectors which serve as a pattern matcher
224    ///   for paths through a hierarchy of named nodes. Each entry in the vector
225    ///   is a selector for a single named node in a data hierarchy. The vector
226    ///   of selectors for named nodes, then, defines a selector on paths through the
227    ///   data hierarchy.
228    ///
229    /// Node paths support wildcarding, which will glob a single level of a
230    /// node hierarchy. eg:
231    ///    root/a/b/*/d
232    /// will match all nodes named d which are below some child of node b.
233    ///    root/a/b/c*
234    /// will match all nodes below b which start with the character "c".
235    pub node_path: Vec<StringSelector>,
236    /// A StringSelector which serves as a pattern matcher for
237    ///   string-named properties on a node in a data hierarchy.
238    ///
239    /// target_properties supports wildcarding, which will match against all properties
240    /// on any node matched by node_path.
241    pub target_properties: StringSelector,
242}
243
244impl fidl::Persistable for PropertySelector {}
245
246/// A selector defining a set of nodes to match, for which the entire subtree including
247/// those nodes are selected.
248#[derive(Clone, Debug, PartialEq)]
249pub struct SubtreeSelector {
250    /// A vector of StringSelectors which serve as a pattern matcher
251    ///   for paths through a hierarchy of named nodes. Each entry in the vector
252    ///   is a selector for a single named node in a data hierarchy. The vector
253    ///   of selectors for named nodes, then, defines a selector on paths through the
254    ///   data hierarchy.
255    ///
256    /// Node paths support wildcarding, which will glob a single level of a
257    /// node hierarchy. eg:
258    ///    root/a/b/*/d
259    /// will match all nodes named d which are below some child of node b.
260    ///    root/a/b/c*
261    /// will match all nodes below b which start with the character "c".
262    pub node_path: Vec<StringSelector>,
263}
264
265impl fidl::Persistable for SubtreeSelector {}
266
267/// Specifies a pattern of component monikers which
268/// identify components being selected for.
269///
270/// Component selectors support wildcarding, which will glob a single "level" of a
271/// component moniker. eg:
272///    core/*/echo
273/// will match all echo instances running only in realms directly under core, but none
274/// nested further.
275///
276/// Component selectors also support a recursive wildcard, which will glob multiple
277/// "levels" of a component moniker. eg:
278///    core/**
279/// will match all component instances running under core/ and all descendants of it.
280/// Note that the wildcard does not select core itself. Clients that wish to choose a
281/// subtree including the root should pass two selectors, eg:
282///    core
283///    core/**
284/// The recursive wildcard is only allowed as the final segment of the selector.
285#[derive(Clone, Debug, Default, PartialEq)]
286pub struct ComponentSelector {
287    /// Vector encoding the a pattern for monikers of components being selected for.
288    /// These monikers are child-monikers relative to a "root" hierarchy that the archivist
289    /// is aware of.
290    ///
291    /// There must be at least one StringSelector provided, which
292    /// specifies the component names that are matched by
293    /// the current selector.
294    pub moniker_segments: Option<Vec<StringSelector>>,
295    #[doc(hidden)]
296    pub __source_breaking: fidl::marker::SourceBreaking,
297}
298
299impl fidl::Persistable for ComponentSelector {}
300
301/// Interest expresses the scope of clients' desired diagnostics data,
302/// e.g. for filtering messages or controlling their generation.
303#[derive(Clone, Debug, Default, PartialEq)]
304pub struct Interest {
305    /// Minimum desired severity. Components should include records at or
306    /// above this severity.
307    ///
308    /// If not present, interpreted as Severity.INFO.
309    pub min_severity: Option<Severity>,
310    #[doc(hidden)]
311    pub __source_breaking: fidl::marker::SourceBreaking,
312}
313
314impl fidl::Persistable for Interest {}
315
316#[derive(Clone, Debug, Default, PartialEq)]
317pub struct LogSettingsSetComponentInterestRequest {
318    /// List of selectors. Required.
319    pub selectors: Option<Vec<LogInterestSelector>>,
320    /// Whether or not to persist the setting change after disconnection.
321    /// Optional. Defaults to false.
322    pub persist: Option<bool>,
323    #[doc(hidden)]
324    pub __source_breaking: fidl::marker::SourceBreaking,
325}
326
327impl fidl::Persistable for LogSettingsSetComponentInterestRequest {}
328
329#[derive(Clone, Debug, Default, PartialEq)]
330pub struct LogStreamOptions {
331    /// What logs to stream through this socket.
332    pub mode: Option<StreamMode>,
333    /// Whether or not to include the moniker in the record arguments.
334    /// Default: false
335    pub include_moniker: Option<bool>,
336    /// Whether or not to include the component url in the record arguments.
337    /// Default: false
338    pub include_component_url: Option<bool>,
339    /// Whether or not to include the number of rolled out logs in the record
340    /// arguments.
341    /// Default: false
342    pub include_rolled_out: Option<bool>,
343    #[doc(hidden)]
344    pub __source_breaking: fidl::marker::SourceBreaking,
345}
346
347impl fidl::Persistable for LogStreamOptions {}
348
349/// Parameters which configure a diagnostics stream's performance properties.
350#[derive(Clone, Debug, Default, PartialEq)]
351pub struct PerformanceConfiguration {
352    /// Maximum aggregate size of all formatted contents returned by
353    /// the batch iterator for a diagnostics stream. If this value is set for a stream
354    /// configured in subscribe mode, the stream will terminate when the max size has
355    /// been reached.
356    /// NOTE: OPTIONAL
357    pub max_aggregate_content_size_bytes: Option<u64>,
358    /// Configuration specifying max number of seconds to wait for a single
359    /// component to have its diagnostics data "pumped". This value can used
360    /// for testing or if you know the component you are interested is in under
361    /// heavy load.
362    /// If not provided, then PER_COMPONENT_ASYNC_TIMEOUT_SECONDS as defined in
363    /// https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master/src/diagnostics/archivist/src/constants.rs
364    /// will be used.
365    /// NOTE: OPTIONAL
366    pub batch_retrieval_timeout_seconds: Option<i64>,
367    #[doc(hidden)]
368    pub __source_breaking: fidl::marker::SourceBreaking,
369}
370
371impl fidl::Persistable for PerformanceConfiguration {}
372
373/// Structured selector containing all required information for pattern-matching onto
374/// string-named properties owned by nodes in a data hierarchy, where data hierarchies belong
375/// to specific components.
376///
377/// These selectors are represented in text form as three segments, colon delimited,
378/// specifying:
379///         <component_moniker>:<node_selector>:<property_selector>
380/// Examples:
381///    Property selection:
382///         realm1/realm2/echo:root/active_users:user_count
383///
384///    Subtree selection:
385///         realm1/realm2/echo:root/active_users
386#[derive(Clone, Debug, Default, PartialEq)]
387pub struct Selector {
388    /// The selector defining a pattern of component monikers to match
389    /// against.
390    pub component_selector: Option<ComponentSelector>,
391    /// The selector defining data hierarchy properties to match against
392    /// within the data hierarchies owned by components matched by
393    /// `component_selector`.
394    pub tree_selector: Option<TreeSelector>,
395    /// A set of fuchsia.inspect.Tree names to filter with before applying
396    /// hierarchy/property selectors.
397    ///
398    /// Omitting a name-filter is equivalent to TreeNames::some(["root"]).
399    /// Note that "root" is the default tree name.
400    pub tree_names: Option<TreeNames>,
401    #[doc(hidden)]
402    pub __source_breaking: fidl::marker::SourceBreaking,
403}
404
405impl fidl::Persistable for Selector {}
406
407/// Parameters needed to configure a stream of diagnostics information.
408#[derive(Clone, Debug, Default, PartialEq)]
409pub struct StreamParameters {
410    /// A [fuchsia.diagnostics/DataType] that specifies the diagnostics data type
411    /// to stream to the client.
412    /// NOTE: REQUIRED
413    pub data_type: Option<DataType>,
414    /// A [fuchsia.diagnostics/StreamMode] that specifies how the
415    /// streaming server provides streamed results.
416    /// NOTE: REQUIRED
417    pub stream_mode: Option<StreamMode>,
418    /// A [fuchsia.diagnostics/Format] that specifies how to format the returned
419    /// diagnostics data.
420    /// NOTE: REQUIRED
421    pub format: Option<Format>,
422    /// Configuration specifying what results the client wants returned from their
423    /// connection. The client can request a specific subset of data using a vector
424    /// of provided selectors, or can specify that they want all available data.
425    /// NOTE: REQUIRED
426    pub client_selector_configuration: Option<ClientSelectorConfiguration>,
427    /// Configuration specifying max number of seconds to wait for a single
428    /// component to have its diagnostics data "pumped". This value can used
429    /// for testing or if you know the component you are interested is in under
430    /// heavy load.
431    /// If not provided, then PER_COMPONENT_ASYNC_TIMEOUT_SECONDS as defined in
432    /// https://fuchsia.googlesource.com/fuchsia/+/refs/heads/master/src/diagnostics/archivist/src/constants.rs
433    /// will be used.
434    /// NOTE: OPTIONAL
435    pub batch_retrieval_timeout_seconds: Option<i64>,
436    /// Parameters which configure a diagnostics stream's performance properties.
437    /// NOTE: OPTIONAL
438    pub performance_configuration: Option<PerformanceConfiguration>,
439    #[doc(hidden)]
440    pub __source_breaking: fidl::marker::SourceBreaking,
441}
442
443impl fidl::Persistable for StreamParameters {}
444
445#[derive(Clone, Debug)]
446pub enum ClientSelectorConfiguration {
447    /// A vector of [fuchsia.diagnostics/SelectorArgument] which
448    /// provide additional filters to scope data streams with. An empty vector is considered
449    /// a misconfiguration and will result in an epitaph signaling incorrect parameters.
450    Selectors(Vec<SelectorArgument>),
451    /// select_all must be true if set, and specifies that the client wants to retrieve
452    /// all data that their connection is able to expose.
453    SelectAll(bool),
454    #[doc(hidden)]
455    __SourceBreaking { unknown_ordinal: u64 },
456}
457
458/// Pattern that matches an unknown `ClientSelectorConfiguration` member.
459#[macro_export]
460macro_rules! ClientSelectorConfigurationUnknown {
461    () => {
462        _
463    };
464}
465
466// Custom PartialEq so that unknown variants are not equal to themselves.
467impl PartialEq for ClientSelectorConfiguration {
468    fn eq(&self, other: &Self) -> bool {
469        match (self, other) {
470            (Self::Selectors(x), Self::Selectors(y)) => *x == *y,
471            (Self::SelectAll(x), Self::SelectAll(y)) => *x == *y,
472            _ => false,
473        }
474    }
475}
476
477impl ClientSelectorConfiguration {
478    #[inline]
479    pub fn ordinal(&self) -> u64 {
480        match *self {
481            Self::Selectors(_) => 1,
482            Self::SelectAll(_) => 2,
483            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
484        }
485    }
486
487    #[inline]
488    pub fn unknown_variant_for_testing() -> Self {
489        Self::__SourceBreaking { unknown_ordinal: 0 }
490    }
491
492    #[inline]
493    pub fn is_unknown(&self) -> bool {
494        match self {
495            Self::__SourceBreaking { .. } => true,
496            _ => false,
497        }
498    }
499}
500
501impl fidl::Persistable for ClientSelectorConfiguration {}
502
503/// Argument used for Archive selectors, can be either the pre-parsed
504/// fidl struct or string representation.
505#[derive(Clone, Debug)]
506pub enum SelectorArgument {
507    /// A Selector defining a pattern-matcher which selects for components within a hierarchy
508    /// and properties in a data hierarchy namespaced by component.
509    StructuredSelector(Selector),
510    /// A raw string representing a [fuchsia.diagnostics/Selector].
511    /// The Selector defines a pattern-matcher which selects for components within a hierarchy
512    /// and properties in a data hierarchy namespaced by component.
513    /// NOTE: All StringSelectors parsed from the raw_selector will be interpreted in
514    ///       string_pattern mode, giving significance to special characters.
515    /// See https://fuchsia.dev/fuchsia-src/reference/diagnostics/selectors for more information
516    RawSelector(String),
517    #[doc(hidden)]
518    __SourceBreaking { unknown_ordinal: u64 },
519}
520
521/// Pattern that matches an unknown `SelectorArgument` member.
522#[macro_export]
523macro_rules! SelectorArgumentUnknown {
524    () => {
525        _
526    };
527}
528
529// Custom PartialEq so that unknown variants are not equal to themselves.
530impl PartialEq for SelectorArgument {
531    fn eq(&self, other: &Self) -> bool {
532        match (self, other) {
533            (Self::StructuredSelector(x), Self::StructuredSelector(y)) => *x == *y,
534            (Self::RawSelector(x), Self::RawSelector(y)) => *x == *y,
535            _ => false,
536        }
537    }
538}
539
540impl SelectorArgument {
541    #[inline]
542    pub fn ordinal(&self) -> u64 {
543        match *self {
544            Self::StructuredSelector(_) => 1,
545            Self::RawSelector(_) => 2,
546            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
547        }
548    }
549
550    #[inline]
551    pub fn unknown_variant_for_testing() -> Self {
552        Self::__SourceBreaking { unknown_ordinal: 0 }
553    }
554
555    #[inline]
556    pub fn is_unknown(&self) -> bool {
557        match self {
558            Self::__SourceBreaking { .. } => true,
559            _ => false,
560        }
561    }
562}
563
564impl fidl::Persistable for SelectorArgument {}
565
566/// StringSelector is an union defining different ways to describe a pattern to match
567/// strings against.
568#[derive(Clone, Debug)]
569pub enum StringSelector {
570    ///   This is a provided string that defines a pattern to
571    ///   match against. The parser treats asterisks (*), colons (:) and backslashes
572    ///   (\) as special characters.
573    ///
574    ///   If you wish to match against literal asterisks (*), they must be escaped.
575    ///   If you wish to match against literal backslashes (\), they must be escaped.
576    ///   If you wish to match against literal colons (:), they must be escaped.
577    ///
578    ///   eg: abc will match any string with the exact name "abc".
579    ///   eg: a\* will match any string with the exact name "a*".
580    ///   eg: a\\* will match any that starts with exactly "a\".
581    ///   eg: a* will match any string that starts with "a".
582    ///   eg: a*b will match any string that starts with a and ends with b.
583    ///   eg: a*b*c will match any string that starts with a and ends with c, with `b`
584    ///       in the middle.
585    ///
586    ///   In addition, the "**" literal is treated as a special sequence that may match
587    ///   multiple levels in a component selector only. See |ComponentSelector| for
588    ///   details.
589    StringPattern(String),
590    ExactMatch(String),
591    #[doc(hidden)]
592    __SourceBreaking {
593        unknown_ordinal: u64,
594    },
595}
596
597/// Pattern that matches an unknown `StringSelector` member.
598#[macro_export]
599macro_rules! StringSelectorUnknown {
600    () => {
601        _
602    };
603}
604
605// Custom PartialEq so that unknown variants are not equal to themselves.
606impl PartialEq for StringSelector {
607    fn eq(&self, other: &Self) -> bool {
608        match (self, other) {
609            (Self::StringPattern(x), Self::StringPattern(y)) => *x == *y,
610            (Self::ExactMatch(x), Self::ExactMatch(y)) => *x == *y,
611            _ => false,
612        }
613    }
614}
615
616impl StringSelector {
617    #[inline]
618    pub fn ordinal(&self) -> u64 {
619        match *self {
620            Self::StringPattern(_) => 1,
621            Self::ExactMatch(_) => 2,
622            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
623        }
624    }
625
626    #[inline]
627    pub fn unknown_variant_for_testing() -> Self {
628        Self::__SourceBreaking { unknown_ordinal: 0 }
629    }
630
631    #[inline]
632    pub fn is_unknown(&self) -> bool {
633        match self {
634            Self::__SourceBreaking { .. } => true,
635            _ => false,
636        }
637    }
638}
639
640impl fidl::Persistable for StringSelector {}
641
642/// TreeNames are the set of names of fuchsia.inspect.Trees for a component that
643/// were parsed out of a selector. The hierarchy and property selector portions
644/// will only be applied to trees that match this set.
645#[derive(Clone, Debug)]
646pub enum TreeNames {
647    /// A specified subset of tree names.
648    Some(Vec<String>),
649    /// All of the available trees. Equivalent to listing all of the names of
650    /// trees.
651    All(All),
652    #[doc(hidden)]
653    __SourceBreaking { unknown_ordinal: u64 },
654}
655
656/// Pattern that matches an unknown `TreeNames` member.
657#[macro_export]
658macro_rules! TreeNamesUnknown {
659    () => {
660        _
661    };
662}
663
664// Custom PartialEq so that unknown variants are not equal to themselves.
665impl PartialEq for TreeNames {
666    fn eq(&self, other: &Self) -> bool {
667        match (self, other) {
668            (Self::Some(x), Self::Some(y)) => *x == *y,
669            (Self::All(x), Self::All(y)) => *x == *y,
670            _ => false,
671        }
672    }
673}
674
675impl TreeNames {
676    #[inline]
677    pub fn ordinal(&self) -> u64 {
678        match *self {
679            Self::Some(_) => 1,
680            Self::All(_) => 2,
681            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
682        }
683    }
684
685    #[inline]
686    pub fn unknown_variant_for_testing() -> Self {
687        Self::__SourceBreaking { unknown_ordinal: 0 }
688    }
689
690    #[inline]
691    pub fn is_unknown(&self) -> bool {
692        match self {
693            Self::__SourceBreaking { .. } => true,
694            _ => false,
695        }
696    }
697}
698
699impl fidl::Persistable for TreeNames {}
700
701/// TreeSelector represents a selection request on a hierarchy of named nodes, with
702/// named properties on those nodes.
703#[derive(Clone, Debug)]
704pub enum TreeSelector {
705    /// A selector defining a set of nodes to match, for which the entire subtree including
706    /// those nodes are selected.
707    SubtreeSelector(SubtreeSelector),
708    /// A selector defining a set of nodes to match, and on those matched nodes a set of named
709    /// propperties to match.
710    PropertySelector(PropertySelector),
711    #[doc(hidden)]
712    __SourceBreaking { unknown_ordinal: u64 },
713}
714
715/// Pattern that matches an unknown `TreeSelector` member.
716#[macro_export]
717macro_rules! TreeSelectorUnknown {
718    () => {
719        _
720    };
721}
722
723// Custom PartialEq so that unknown variants are not equal to themselves.
724impl PartialEq for TreeSelector {
725    fn eq(&self, other: &Self) -> bool {
726        match (self, other) {
727            (Self::SubtreeSelector(x), Self::SubtreeSelector(y)) => *x == *y,
728            (Self::PropertySelector(x), Self::PropertySelector(y)) => *x == *y,
729            _ => false,
730        }
731    }
732}
733
734impl TreeSelector {
735    #[inline]
736    pub fn ordinal(&self) -> u64 {
737        match *self {
738            Self::SubtreeSelector(_) => 1,
739            Self::PropertySelector(_) => 2,
740            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
741        }
742    }
743
744    #[inline]
745    pub fn unknown_variant_for_testing() -> Self {
746        Self::__SourceBreaking { unknown_ordinal: 0 }
747    }
748
749    #[inline]
750    pub fn is_unknown(&self) -> bool {
751        match self {
752            Self::__SourceBreaking { .. } => true,
753            _ => false,
754        }
755    }
756}
757
758impl fidl::Persistable for TreeSelector {}
759
760pub mod archive_accessor_ordinals {
761    pub const STREAM_DIAGNOSTICS: u64 = 0x20c73e2ecd653c3e;
762    pub const WAIT_FOR_READY: u64 = 0x122963198011bd24;
763}
764
765pub mod batch_iterator_ordinals {
766    pub const GET_NEXT: u64 = 0x781986486c6254a5;
767    pub const WAIT_FOR_READY: u64 = 0x70598ee271597603;
768}
769
770pub mod log_settings_ordinals {
771    pub const REGISTER_INTEREST: u64 = 0x49d7c14eec975fb;
772    pub const SET_INTEREST: u64 = 0x71beced9d2411f90;
773    pub const SET_COMPONENT_INTEREST: u64 = 0x35f7004d2367f6c1;
774}
775
776pub mod log_stream_ordinals {
777    pub const CONNECT: u64 = 0x745eb34f10d51a88;
778}
779
780mod internal {
781    use super::*;
782    unsafe impl fidl::encoding::TypeMarker for DataType {
783        type Owned = Self;
784
785        #[inline(always)]
786        fn inline_align(_context: fidl::encoding::Context) -> usize {
787            std::mem::align_of::<u8>()
788        }
789
790        #[inline(always)]
791        fn inline_size(_context: fidl::encoding::Context) -> usize {
792            std::mem::size_of::<u8>()
793        }
794
795        #[inline(always)]
796        fn encode_is_copy() -> bool {
797            true
798        }
799
800        #[inline(always)]
801        fn decode_is_copy() -> bool {
802            false
803        }
804    }
805
806    impl fidl::encoding::ValueTypeMarker for DataType {
807        type Borrowed<'a> = Self;
808        #[inline(always)]
809        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
810            *value
811        }
812    }
813
814    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DataType {
815        #[inline]
816        unsafe fn encode(
817            self,
818            encoder: &mut fidl::encoding::Encoder<'_, D>,
819            offset: usize,
820            _depth: fidl::encoding::Depth,
821        ) -> fidl::Result<()> {
822            encoder.debug_check_bounds::<Self>(offset);
823            encoder.write_num(self.into_primitive(), offset);
824            Ok(())
825        }
826    }
827
828    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DataType {
829        #[inline(always)]
830        fn new_empty() -> Self {
831            Self::Inspect
832        }
833
834        #[inline]
835        unsafe fn decode(
836            &mut self,
837            decoder: &mut fidl::encoding::Decoder<'_, D>,
838            offset: usize,
839            _depth: fidl::encoding::Depth,
840        ) -> fidl::Result<()> {
841            decoder.debug_check_bounds::<Self>(offset);
842            let prim = decoder.read_num::<u8>(offset);
843
844            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
845            Ok(())
846        }
847    }
848    unsafe impl fidl::encoding::TypeMarker for Format {
849        type Owned = Self;
850
851        #[inline(always)]
852        fn inline_align(_context: fidl::encoding::Context) -> usize {
853            std::mem::align_of::<u32>()
854        }
855
856        #[inline(always)]
857        fn inline_size(_context: fidl::encoding::Context) -> usize {
858            std::mem::size_of::<u32>()
859        }
860
861        #[inline(always)]
862        fn encode_is_copy() -> bool {
863            true
864        }
865
866        #[inline(always)]
867        fn decode_is_copy() -> bool {
868            false
869        }
870    }
871
872    impl fidl::encoding::ValueTypeMarker for Format {
873        type Borrowed<'a> = Self;
874        #[inline(always)]
875        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
876            *value
877        }
878    }
879
880    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Format {
881        #[inline]
882        unsafe fn encode(
883            self,
884            encoder: &mut fidl::encoding::Encoder<'_, D>,
885            offset: usize,
886            _depth: fidl::encoding::Depth,
887        ) -> fidl::Result<()> {
888            encoder.debug_check_bounds::<Self>(offset);
889            encoder.write_num(self.into_primitive(), offset);
890            Ok(())
891        }
892    }
893
894    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Format {
895        #[inline(always)]
896        fn new_empty() -> Self {
897            Self::Json
898        }
899
900        #[inline]
901        unsafe fn decode(
902            &mut self,
903            decoder: &mut fidl::encoding::Decoder<'_, D>,
904            offset: usize,
905            _depth: fidl::encoding::Depth,
906        ) -> fidl::Result<()> {
907            decoder.debug_check_bounds::<Self>(offset);
908            let prim = decoder.read_num::<u32>(offset);
909
910            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
911            Ok(())
912        }
913    }
914    unsafe impl fidl::encoding::TypeMarker for ReaderError {
915        type Owned = Self;
916
917        #[inline(always)]
918        fn inline_align(_context: fidl::encoding::Context) -> usize {
919            std::mem::align_of::<u32>()
920        }
921
922        #[inline(always)]
923        fn inline_size(_context: fidl::encoding::Context) -> usize {
924            std::mem::size_of::<u32>()
925        }
926
927        #[inline(always)]
928        fn encode_is_copy() -> bool {
929            true
930        }
931
932        #[inline(always)]
933        fn decode_is_copy() -> bool {
934            false
935        }
936    }
937
938    impl fidl::encoding::ValueTypeMarker for ReaderError {
939        type Borrowed<'a> = Self;
940        #[inline(always)]
941        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
942            *value
943        }
944    }
945
946    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReaderError {
947        #[inline]
948        unsafe fn encode(
949            self,
950            encoder: &mut fidl::encoding::Encoder<'_, D>,
951            offset: usize,
952            _depth: fidl::encoding::Depth,
953        ) -> fidl::Result<()> {
954            encoder.debug_check_bounds::<Self>(offset);
955            encoder.write_num(self.into_primitive(), offset);
956            Ok(())
957        }
958    }
959
960    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReaderError {
961        #[inline(always)]
962        fn new_empty() -> Self {
963            Self::Io
964        }
965
966        #[inline]
967        unsafe fn decode(
968            &mut self,
969            decoder: &mut fidl::encoding::Decoder<'_, D>,
970            offset: usize,
971            _depth: fidl::encoding::Depth,
972        ) -> fidl::Result<()> {
973            decoder.debug_check_bounds::<Self>(offset);
974            let prim = decoder.read_num::<u32>(offset);
975
976            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
977            Ok(())
978        }
979    }
980    unsafe impl fidl::encoding::TypeMarker for Severity {
981        type Owned = Self;
982
983        #[inline(always)]
984        fn inline_align(_context: fidl::encoding::Context) -> usize {
985            std::mem::align_of::<u8>()
986        }
987
988        #[inline(always)]
989        fn inline_size(_context: fidl::encoding::Context) -> usize {
990            std::mem::size_of::<u8>()
991        }
992
993        #[inline(always)]
994        fn encode_is_copy() -> bool {
995            true
996        }
997
998        #[inline(always)]
999        fn decode_is_copy() -> bool {
1000            false
1001        }
1002    }
1003
1004    impl fidl::encoding::ValueTypeMarker for Severity {
1005        type Borrowed<'a> = Self;
1006        #[inline(always)]
1007        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1008            *value
1009        }
1010    }
1011
1012    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Severity {
1013        #[inline]
1014        unsafe fn encode(
1015            self,
1016            encoder: &mut fidl::encoding::Encoder<'_, D>,
1017            offset: usize,
1018            _depth: fidl::encoding::Depth,
1019        ) -> fidl::Result<()> {
1020            encoder.debug_check_bounds::<Self>(offset);
1021            encoder.write_num(self.into_primitive(), offset);
1022            Ok(())
1023        }
1024    }
1025
1026    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Severity {
1027        #[inline(always)]
1028        fn new_empty() -> Self {
1029            Self::Trace
1030        }
1031
1032        #[inline]
1033        unsafe fn decode(
1034            &mut self,
1035            decoder: &mut fidl::encoding::Decoder<'_, D>,
1036            offset: usize,
1037            _depth: fidl::encoding::Depth,
1038        ) -> fidl::Result<()> {
1039            decoder.debug_check_bounds::<Self>(offset);
1040            let prim = decoder.read_num::<u8>(offset);
1041
1042            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1043            Ok(())
1044        }
1045    }
1046    unsafe impl fidl::encoding::TypeMarker for StreamMode {
1047        type Owned = Self;
1048
1049        #[inline(always)]
1050        fn inline_align(_context: fidl::encoding::Context) -> usize {
1051            std::mem::align_of::<u8>()
1052        }
1053
1054        #[inline(always)]
1055        fn inline_size(_context: fidl::encoding::Context) -> usize {
1056            std::mem::size_of::<u8>()
1057        }
1058
1059        #[inline(always)]
1060        fn encode_is_copy() -> bool {
1061            true
1062        }
1063
1064        #[inline(always)]
1065        fn decode_is_copy() -> bool {
1066            false
1067        }
1068    }
1069
1070    impl fidl::encoding::ValueTypeMarker for StreamMode {
1071        type Borrowed<'a> = Self;
1072        #[inline(always)]
1073        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1074            *value
1075        }
1076    }
1077
1078    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for StreamMode {
1079        #[inline]
1080        unsafe fn encode(
1081            self,
1082            encoder: &mut fidl::encoding::Encoder<'_, D>,
1083            offset: usize,
1084            _depth: fidl::encoding::Depth,
1085        ) -> fidl::Result<()> {
1086            encoder.debug_check_bounds::<Self>(offset);
1087            encoder.write_num(self.into_primitive(), offset);
1088            Ok(())
1089        }
1090    }
1091
1092    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamMode {
1093        #[inline(always)]
1094        fn new_empty() -> Self {
1095            Self::Snapshot
1096        }
1097
1098        #[inline]
1099        unsafe fn decode(
1100            &mut self,
1101            decoder: &mut fidl::encoding::Decoder<'_, D>,
1102            offset: usize,
1103            _depth: fidl::encoding::Depth,
1104        ) -> fidl::Result<()> {
1105            decoder.debug_check_bounds::<Self>(offset);
1106            let prim = decoder.read_num::<u8>(offset);
1107
1108            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1109            Ok(())
1110        }
1111    }
1112
1113    impl fidl::encoding::ValueTypeMarker for All {
1114        type Borrowed<'a> = &'a Self;
1115        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1116            value
1117        }
1118    }
1119
1120    unsafe impl fidl::encoding::TypeMarker for All {
1121        type Owned = Self;
1122
1123        #[inline(always)]
1124        fn inline_align(_context: fidl::encoding::Context) -> usize {
1125            1
1126        }
1127
1128        #[inline(always)]
1129        fn inline_size(_context: fidl::encoding::Context) -> usize {
1130            1
1131        }
1132    }
1133
1134    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<All, D> for &All {
1135        #[inline]
1136        unsafe fn encode(
1137            self,
1138            encoder: &mut fidl::encoding::Encoder<'_, D>,
1139            offset: usize,
1140            _depth: fidl::encoding::Depth,
1141        ) -> fidl::Result<()> {
1142            encoder.debug_check_bounds::<All>(offset);
1143            encoder.write_num(0u8, offset);
1144            Ok(())
1145        }
1146    }
1147
1148    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for All {
1149        #[inline(always)]
1150        fn new_empty() -> Self {
1151            Self
1152        }
1153
1154        #[inline]
1155        unsafe fn decode(
1156            &mut self,
1157            decoder: &mut fidl::encoding::Decoder<'_, D>,
1158            offset: usize,
1159            _depth: fidl::encoding::Depth,
1160        ) -> fidl::Result<()> {
1161            decoder.debug_check_bounds::<Self>(offset);
1162            match decoder.read_num::<u8>(offset) {
1163                0 => Ok(()),
1164                _ => Err(fidl::Error::Invalid),
1165            }
1166        }
1167    }
1168
1169    impl fidl::encoding::ValueTypeMarker for LogInterestSelector {
1170        type Borrowed<'a> = &'a Self;
1171        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1172            value
1173        }
1174    }
1175
1176    unsafe impl fidl::encoding::TypeMarker for LogInterestSelector {
1177        type Owned = Self;
1178
1179        #[inline(always)]
1180        fn inline_align(_context: fidl::encoding::Context) -> usize {
1181            8
1182        }
1183
1184        #[inline(always)]
1185        fn inline_size(_context: fidl::encoding::Context) -> usize {
1186            32
1187        }
1188    }
1189
1190    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LogInterestSelector, D>
1191        for &LogInterestSelector
1192    {
1193        #[inline]
1194        unsafe fn encode(
1195            self,
1196            encoder: &mut fidl::encoding::Encoder<'_, D>,
1197            offset: usize,
1198            _depth: fidl::encoding::Depth,
1199        ) -> fidl::Result<()> {
1200            encoder.debug_check_bounds::<LogInterestSelector>(offset);
1201            // Delegate to tuple encoding.
1202            fidl::encoding::Encode::<LogInterestSelector, D>::encode(
1203                (
1204                    <ComponentSelector as fidl::encoding::ValueTypeMarker>::borrow(&self.selector),
1205                    <fidl_fuchsia_diagnostics_types__common::Interest as fidl::encoding::ValueTypeMarker>::borrow(&self.interest),
1206                ),
1207                encoder, offset, _depth
1208            )
1209        }
1210    }
1211    unsafe impl<
1212            D: fidl::encoding::ResourceDialect,
1213            T0: fidl::encoding::Encode<ComponentSelector, D>,
1214            T1: fidl::encoding::Encode<fidl_fuchsia_diagnostics_types__common::Interest, D>,
1215        > fidl::encoding::Encode<LogInterestSelector, D> for (T0, T1)
1216    {
1217        #[inline]
1218        unsafe fn encode(
1219            self,
1220            encoder: &mut fidl::encoding::Encoder<'_, D>,
1221            offset: usize,
1222            depth: fidl::encoding::Depth,
1223        ) -> fidl::Result<()> {
1224            encoder.debug_check_bounds::<LogInterestSelector>(offset);
1225            // Zero out padding regions. There's no need to apply masks
1226            // because the unmasked parts will be overwritten by fields.
1227            // Write the fields.
1228            self.0.encode(encoder, offset + 0, depth)?;
1229            self.1.encode(encoder, offset + 16, depth)?;
1230            Ok(())
1231        }
1232    }
1233
1234    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogInterestSelector {
1235        #[inline(always)]
1236        fn new_empty() -> Self {
1237            Self {
1238                selector: fidl::new_empty!(ComponentSelector, D),
1239                interest: fidl::new_empty!(fidl_fuchsia_diagnostics_types__common::Interest, D),
1240            }
1241        }
1242
1243        #[inline]
1244        unsafe fn decode(
1245            &mut self,
1246            decoder: &mut fidl::encoding::Decoder<'_, D>,
1247            offset: usize,
1248            _depth: fidl::encoding::Depth,
1249        ) -> fidl::Result<()> {
1250            decoder.debug_check_bounds::<Self>(offset);
1251            // Verify that padding bytes are zero.
1252            fidl::decode!(ComponentSelector, D, &mut self.selector, decoder, offset + 0, _depth)?;
1253            fidl::decode!(
1254                fidl_fuchsia_diagnostics_types__common::Interest,
1255                D,
1256                &mut self.interest,
1257                decoder,
1258                offset + 16,
1259                _depth
1260            )?;
1261            Ok(())
1262        }
1263    }
1264
1265    impl fidl::encoding::ValueTypeMarker for LogSettingsRegisterInterestRequest {
1266        type Borrowed<'a> = &'a Self;
1267        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1268            value
1269        }
1270    }
1271
1272    unsafe impl fidl::encoding::TypeMarker for LogSettingsRegisterInterestRequest {
1273        type Owned = Self;
1274
1275        #[inline(always)]
1276        fn inline_align(_context: fidl::encoding::Context) -> usize {
1277            8
1278        }
1279
1280        #[inline(always)]
1281        fn inline_size(_context: fidl::encoding::Context) -> usize {
1282            16
1283        }
1284    }
1285
1286    unsafe impl<D: fidl::encoding::ResourceDialect>
1287        fidl::encoding::Encode<LogSettingsRegisterInterestRequest, D>
1288        for &LogSettingsRegisterInterestRequest
1289    {
1290        #[inline]
1291        unsafe fn encode(
1292            self,
1293            encoder: &mut fidl::encoding::Encoder<'_, D>,
1294            offset: usize,
1295            _depth: fidl::encoding::Depth,
1296        ) -> fidl::Result<()> {
1297            encoder.debug_check_bounds::<LogSettingsRegisterInterestRequest>(offset);
1298            // Delegate to tuple encoding.
1299            fidl::encoding::Encode::<LogSettingsRegisterInterestRequest, D>::encode(
1300                (
1301                    <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.selectors),
1302                ),
1303                encoder, offset, _depth
1304            )
1305        }
1306    }
1307    unsafe impl<
1308            D: fidl::encoding::ResourceDialect,
1309            T0: fidl::encoding::Encode<fidl::encoding::Vector<LogInterestSelector, 64>, D>,
1310        > fidl::encoding::Encode<LogSettingsRegisterInterestRequest, D> for (T0,)
1311    {
1312        #[inline]
1313        unsafe fn encode(
1314            self,
1315            encoder: &mut fidl::encoding::Encoder<'_, D>,
1316            offset: usize,
1317            depth: fidl::encoding::Depth,
1318        ) -> fidl::Result<()> {
1319            encoder.debug_check_bounds::<LogSettingsRegisterInterestRequest>(offset);
1320            // Zero out padding regions. There's no need to apply masks
1321            // because the unmasked parts will be overwritten by fields.
1322            // Write the fields.
1323            self.0.encode(encoder, offset + 0, depth)?;
1324            Ok(())
1325        }
1326    }
1327
1328    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1329        for LogSettingsRegisterInterestRequest
1330    {
1331        #[inline(always)]
1332        fn new_empty() -> Self {
1333            Self { selectors: fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D) }
1334        }
1335
1336        #[inline]
1337        unsafe fn decode(
1338            &mut self,
1339            decoder: &mut fidl::encoding::Decoder<'_, D>,
1340            offset: usize,
1341            _depth: fidl::encoding::Depth,
1342        ) -> fidl::Result<()> {
1343            decoder.debug_check_bounds::<Self>(offset);
1344            // Verify that padding bytes are zero.
1345            fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, &mut self.selectors, decoder, offset + 0, _depth)?;
1346            Ok(())
1347        }
1348    }
1349
1350    impl fidl::encoding::ValueTypeMarker for LogSettingsSetInterestRequest {
1351        type Borrowed<'a> = &'a Self;
1352        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1353            value
1354        }
1355    }
1356
1357    unsafe impl fidl::encoding::TypeMarker for LogSettingsSetInterestRequest {
1358        type Owned = Self;
1359
1360        #[inline(always)]
1361        fn inline_align(_context: fidl::encoding::Context) -> usize {
1362            8
1363        }
1364
1365        #[inline(always)]
1366        fn inline_size(_context: fidl::encoding::Context) -> usize {
1367            16
1368        }
1369    }
1370
1371    unsafe impl<D: fidl::encoding::ResourceDialect>
1372        fidl::encoding::Encode<LogSettingsSetInterestRequest, D>
1373        for &LogSettingsSetInterestRequest
1374    {
1375        #[inline]
1376        unsafe fn encode(
1377            self,
1378            encoder: &mut fidl::encoding::Encoder<'_, D>,
1379            offset: usize,
1380            _depth: fidl::encoding::Depth,
1381        ) -> fidl::Result<()> {
1382            encoder.debug_check_bounds::<LogSettingsSetInterestRequest>(offset);
1383            // Delegate to tuple encoding.
1384            fidl::encoding::Encode::<LogSettingsSetInterestRequest, D>::encode(
1385                (
1386                    <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.selectors),
1387                ),
1388                encoder, offset, _depth
1389            )
1390        }
1391    }
1392    unsafe impl<
1393            D: fidl::encoding::ResourceDialect,
1394            T0: fidl::encoding::Encode<fidl::encoding::Vector<LogInterestSelector, 64>, D>,
1395        > fidl::encoding::Encode<LogSettingsSetInterestRequest, D> for (T0,)
1396    {
1397        #[inline]
1398        unsafe fn encode(
1399            self,
1400            encoder: &mut fidl::encoding::Encoder<'_, D>,
1401            offset: usize,
1402            depth: fidl::encoding::Depth,
1403        ) -> fidl::Result<()> {
1404            encoder.debug_check_bounds::<LogSettingsSetInterestRequest>(offset);
1405            // Zero out padding regions. There's no need to apply masks
1406            // because the unmasked parts will be overwritten by fields.
1407            // Write the fields.
1408            self.0.encode(encoder, offset + 0, depth)?;
1409            Ok(())
1410        }
1411    }
1412
1413    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1414        for LogSettingsSetInterestRequest
1415    {
1416        #[inline(always)]
1417        fn new_empty() -> Self {
1418            Self { selectors: fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D) }
1419        }
1420
1421        #[inline]
1422        unsafe fn decode(
1423            &mut self,
1424            decoder: &mut fidl::encoding::Decoder<'_, D>,
1425            offset: usize,
1426            _depth: fidl::encoding::Depth,
1427        ) -> fidl::Result<()> {
1428            decoder.debug_check_bounds::<Self>(offset);
1429            // Verify that padding bytes are zero.
1430            fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, &mut self.selectors, decoder, offset + 0, _depth)?;
1431            Ok(())
1432        }
1433    }
1434
1435    impl fidl::encoding::ValueTypeMarker for PropertySelector {
1436        type Borrowed<'a> = &'a Self;
1437        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1438            value
1439        }
1440    }
1441
1442    unsafe impl fidl::encoding::TypeMarker for PropertySelector {
1443        type Owned = Self;
1444
1445        #[inline(always)]
1446        fn inline_align(_context: fidl::encoding::Context) -> usize {
1447            8
1448        }
1449
1450        #[inline(always)]
1451        fn inline_size(_context: fidl::encoding::Context) -> usize {
1452            32
1453        }
1454    }
1455
1456    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PropertySelector, D>
1457        for &PropertySelector
1458    {
1459        #[inline]
1460        unsafe fn encode(
1461            self,
1462            encoder: &mut fidl::encoding::Encoder<'_, D>,
1463            offset: usize,
1464            _depth: fidl::encoding::Depth,
1465        ) -> fidl::Result<()> {
1466            encoder.debug_check_bounds::<PropertySelector>(offset);
1467            // Delegate to tuple encoding.
1468            fidl::encoding::Encode::<PropertySelector, D>::encode(
1469                (
1470                    <fidl::encoding::Vector<StringSelector, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.node_path),
1471                    <StringSelector as fidl::encoding::ValueTypeMarker>::borrow(&self.target_properties),
1472                ),
1473                encoder, offset, _depth
1474            )
1475        }
1476    }
1477    unsafe impl<
1478            D: fidl::encoding::ResourceDialect,
1479            T0: fidl::encoding::Encode<fidl::encoding::Vector<StringSelector, 100>, D>,
1480            T1: fidl::encoding::Encode<StringSelector, D>,
1481        > fidl::encoding::Encode<PropertySelector, D> for (T0, T1)
1482    {
1483        #[inline]
1484        unsafe fn encode(
1485            self,
1486            encoder: &mut fidl::encoding::Encoder<'_, D>,
1487            offset: usize,
1488            depth: fidl::encoding::Depth,
1489        ) -> fidl::Result<()> {
1490            encoder.debug_check_bounds::<PropertySelector>(offset);
1491            // Zero out padding regions. There's no need to apply masks
1492            // because the unmasked parts will be overwritten by fields.
1493            // Write the fields.
1494            self.0.encode(encoder, offset + 0, depth)?;
1495            self.1.encode(encoder, offset + 16, depth)?;
1496            Ok(())
1497        }
1498    }
1499
1500    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PropertySelector {
1501        #[inline(always)]
1502        fn new_empty() -> Self {
1503            Self {
1504                node_path: fidl::new_empty!(fidl::encoding::Vector<StringSelector, 100>, D),
1505                target_properties: fidl::new_empty!(StringSelector, D),
1506            }
1507        }
1508
1509        #[inline]
1510        unsafe fn decode(
1511            &mut self,
1512            decoder: &mut fidl::encoding::Decoder<'_, D>,
1513            offset: usize,
1514            _depth: fidl::encoding::Depth,
1515        ) -> fidl::Result<()> {
1516            decoder.debug_check_bounds::<Self>(offset);
1517            // Verify that padding bytes are zero.
1518            fidl::decode!(fidl::encoding::Vector<StringSelector, 100>, D, &mut self.node_path, decoder, offset + 0, _depth)?;
1519            fidl::decode!(
1520                StringSelector,
1521                D,
1522                &mut self.target_properties,
1523                decoder,
1524                offset + 16,
1525                _depth
1526            )?;
1527            Ok(())
1528        }
1529    }
1530
1531    impl fidl::encoding::ValueTypeMarker for SubtreeSelector {
1532        type Borrowed<'a> = &'a Self;
1533        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1534            value
1535        }
1536    }
1537
1538    unsafe impl fidl::encoding::TypeMarker for SubtreeSelector {
1539        type Owned = Self;
1540
1541        #[inline(always)]
1542        fn inline_align(_context: fidl::encoding::Context) -> usize {
1543            8
1544        }
1545
1546        #[inline(always)]
1547        fn inline_size(_context: fidl::encoding::Context) -> usize {
1548            16
1549        }
1550    }
1551
1552    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SubtreeSelector, D>
1553        for &SubtreeSelector
1554    {
1555        #[inline]
1556        unsafe fn encode(
1557            self,
1558            encoder: &mut fidl::encoding::Encoder<'_, D>,
1559            offset: usize,
1560            _depth: fidl::encoding::Depth,
1561        ) -> fidl::Result<()> {
1562            encoder.debug_check_bounds::<SubtreeSelector>(offset);
1563            // Delegate to tuple encoding.
1564            fidl::encoding::Encode::<SubtreeSelector, D>::encode(
1565                (
1566                    <fidl::encoding::Vector<StringSelector, 100> as fidl::encoding::ValueTypeMarker>::borrow(&self.node_path),
1567                ),
1568                encoder, offset, _depth
1569            )
1570        }
1571    }
1572    unsafe impl<
1573            D: fidl::encoding::ResourceDialect,
1574            T0: fidl::encoding::Encode<fidl::encoding::Vector<StringSelector, 100>, D>,
1575        > fidl::encoding::Encode<SubtreeSelector, D> for (T0,)
1576    {
1577        #[inline]
1578        unsafe fn encode(
1579            self,
1580            encoder: &mut fidl::encoding::Encoder<'_, D>,
1581            offset: usize,
1582            depth: fidl::encoding::Depth,
1583        ) -> fidl::Result<()> {
1584            encoder.debug_check_bounds::<SubtreeSelector>(offset);
1585            // Zero out padding regions. There's no need to apply masks
1586            // because the unmasked parts will be overwritten by fields.
1587            // Write the fields.
1588            self.0.encode(encoder, offset + 0, depth)?;
1589            Ok(())
1590        }
1591    }
1592
1593    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SubtreeSelector {
1594        #[inline(always)]
1595        fn new_empty() -> Self {
1596            Self { node_path: fidl::new_empty!(fidl::encoding::Vector<StringSelector, 100>, D) }
1597        }
1598
1599        #[inline]
1600        unsafe fn decode(
1601            &mut self,
1602            decoder: &mut fidl::encoding::Decoder<'_, D>,
1603            offset: usize,
1604            _depth: fidl::encoding::Depth,
1605        ) -> fidl::Result<()> {
1606            decoder.debug_check_bounds::<Self>(offset);
1607            // Verify that padding bytes are zero.
1608            fidl::decode!(fidl::encoding::Vector<StringSelector, 100>, D, &mut self.node_path, decoder, offset + 0, _depth)?;
1609            Ok(())
1610        }
1611    }
1612
1613    impl ComponentSelector {
1614        #[inline(always)]
1615        fn max_ordinal_present(&self) -> u64 {
1616            if let Some(_) = self.moniker_segments {
1617                return 1;
1618            }
1619            0
1620        }
1621    }
1622
1623    impl fidl::encoding::ValueTypeMarker for ComponentSelector {
1624        type Borrowed<'a> = &'a Self;
1625        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1626            value
1627        }
1628    }
1629
1630    unsafe impl fidl::encoding::TypeMarker for ComponentSelector {
1631        type Owned = Self;
1632
1633        #[inline(always)]
1634        fn inline_align(_context: fidl::encoding::Context) -> usize {
1635            8
1636        }
1637
1638        #[inline(always)]
1639        fn inline_size(_context: fidl::encoding::Context) -> usize {
1640            16
1641        }
1642    }
1643
1644    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ComponentSelector, D>
1645        for &ComponentSelector
1646    {
1647        unsafe fn encode(
1648            self,
1649            encoder: &mut fidl::encoding::Encoder<'_, D>,
1650            offset: usize,
1651            mut depth: fidl::encoding::Depth,
1652        ) -> fidl::Result<()> {
1653            encoder.debug_check_bounds::<ComponentSelector>(offset);
1654            // Vector header
1655            let max_ordinal: u64 = self.max_ordinal_present();
1656            encoder.write_num(max_ordinal, offset);
1657            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1658            // Calling encoder.out_of_line_offset(0) is not allowed.
1659            if max_ordinal == 0 {
1660                return Ok(());
1661            }
1662            depth.increment()?;
1663            let envelope_size = 8;
1664            let bytes_len = max_ordinal as usize * envelope_size;
1665            #[allow(unused_variables)]
1666            let offset = encoder.out_of_line_offset(bytes_len);
1667            let mut _prev_end_offset: usize = 0;
1668            if 1 > max_ordinal {
1669                return Ok(());
1670            }
1671
1672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1673            // are envelope_size bytes.
1674            let cur_offset: usize = (1 - 1) * envelope_size;
1675
1676            // Zero reserved fields.
1677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1678
1679            // Safety:
1680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1682            //   envelope_size bytes, there is always sufficient room.
1683            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<StringSelector, 25>, D>(
1684            self.moniker_segments.as_ref().map(<fidl::encoding::Vector<StringSelector, 25> as fidl::encoding::ValueTypeMarker>::borrow),
1685            encoder, offset + cur_offset, depth
1686        )?;
1687
1688            _prev_end_offset = cur_offset + envelope_size;
1689
1690            Ok(())
1691        }
1692    }
1693
1694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ComponentSelector {
1695        #[inline(always)]
1696        fn new_empty() -> Self {
1697            Self::default()
1698        }
1699
1700        unsafe fn decode(
1701            &mut self,
1702            decoder: &mut fidl::encoding::Decoder<'_, D>,
1703            offset: usize,
1704            mut depth: fidl::encoding::Depth,
1705        ) -> fidl::Result<()> {
1706            decoder.debug_check_bounds::<Self>(offset);
1707            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1708                None => return Err(fidl::Error::NotNullable),
1709                Some(len) => len,
1710            };
1711            // Calling decoder.out_of_line_offset(0) is not allowed.
1712            if len == 0 {
1713                return Ok(());
1714            };
1715            depth.increment()?;
1716            let envelope_size = 8;
1717            let bytes_len = len * envelope_size;
1718            let offset = decoder.out_of_line_offset(bytes_len)?;
1719            // Decode the envelope for each type.
1720            let mut _next_ordinal_to_read = 0;
1721            let mut next_offset = offset;
1722            let end_offset = offset + bytes_len;
1723            _next_ordinal_to_read += 1;
1724            if next_offset >= end_offset {
1725                return Ok(());
1726            }
1727
1728            // Decode unknown envelopes for gaps in ordinals.
1729            while _next_ordinal_to_read < 1 {
1730                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1731                _next_ordinal_to_read += 1;
1732                next_offset += envelope_size;
1733            }
1734
1735            let next_out_of_line = decoder.next_out_of_line();
1736            let handles_before = decoder.remaining_handles();
1737            if let Some((inlined, num_bytes, num_handles)) =
1738                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1739            {
1740                let member_inline_size = <fidl::encoding::Vector<StringSelector, 25> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1741                if inlined != (member_inline_size <= 4) {
1742                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1743                }
1744                let inner_offset;
1745                let mut inner_depth = depth.clone();
1746                if inlined {
1747                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1748                    inner_offset = next_offset;
1749                } else {
1750                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1751                    inner_depth.increment()?;
1752                }
1753                let val_ref = self.moniker_segments.get_or_insert_with(
1754                    || fidl::new_empty!(fidl::encoding::Vector<StringSelector, 25>, D),
1755                );
1756                fidl::decode!(fidl::encoding::Vector<StringSelector, 25>, D, val_ref, decoder, inner_offset, inner_depth)?;
1757                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1758                {
1759                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1760                }
1761                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1762                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1763                }
1764            }
1765
1766            next_offset += envelope_size;
1767
1768            // Decode the remaining unknown envelopes.
1769            while next_offset < end_offset {
1770                _next_ordinal_to_read += 1;
1771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1772                next_offset += envelope_size;
1773            }
1774
1775            Ok(())
1776        }
1777    }
1778
1779    impl Interest {
1780        #[inline(always)]
1781        fn max_ordinal_present(&self) -> u64 {
1782            if let Some(_) = self.min_severity {
1783                return 1;
1784            }
1785            0
1786        }
1787    }
1788
1789    impl fidl::encoding::ValueTypeMarker for Interest {
1790        type Borrowed<'a> = &'a Self;
1791        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1792            value
1793        }
1794    }
1795
1796    unsafe impl fidl::encoding::TypeMarker for Interest {
1797        type Owned = Self;
1798
1799        #[inline(always)]
1800        fn inline_align(_context: fidl::encoding::Context) -> usize {
1801            8
1802        }
1803
1804        #[inline(always)]
1805        fn inline_size(_context: fidl::encoding::Context) -> usize {
1806            16
1807        }
1808    }
1809
1810    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Interest, D> for &Interest {
1811        unsafe fn encode(
1812            self,
1813            encoder: &mut fidl::encoding::Encoder<'_, D>,
1814            offset: usize,
1815            mut depth: fidl::encoding::Depth,
1816        ) -> fidl::Result<()> {
1817            encoder.debug_check_bounds::<Interest>(offset);
1818            // Vector header
1819            let max_ordinal: u64 = self.max_ordinal_present();
1820            encoder.write_num(max_ordinal, offset);
1821            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1822            // Calling encoder.out_of_line_offset(0) is not allowed.
1823            if max_ordinal == 0 {
1824                return Ok(());
1825            }
1826            depth.increment()?;
1827            let envelope_size = 8;
1828            let bytes_len = max_ordinal as usize * envelope_size;
1829            #[allow(unused_variables)]
1830            let offset = encoder.out_of_line_offset(bytes_len);
1831            let mut _prev_end_offset: usize = 0;
1832            if 1 > max_ordinal {
1833                return Ok(());
1834            }
1835
1836            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1837            // are envelope_size bytes.
1838            let cur_offset: usize = (1 - 1) * envelope_size;
1839
1840            // Zero reserved fields.
1841            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1842
1843            // Safety:
1844            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1845            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1846            //   envelope_size bytes, there is always sufficient room.
1847            fidl::encoding::encode_in_envelope_optional::<Severity, D>(
1848                self.min_severity
1849                    .as_ref()
1850                    .map(<Severity as fidl::encoding::ValueTypeMarker>::borrow),
1851                encoder,
1852                offset + cur_offset,
1853                depth,
1854            )?;
1855
1856            _prev_end_offset = cur_offset + envelope_size;
1857
1858            Ok(())
1859        }
1860    }
1861
1862    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Interest {
1863        #[inline(always)]
1864        fn new_empty() -> Self {
1865            Self::default()
1866        }
1867
1868        unsafe fn decode(
1869            &mut self,
1870            decoder: &mut fidl::encoding::Decoder<'_, D>,
1871            offset: usize,
1872            mut depth: fidl::encoding::Depth,
1873        ) -> fidl::Result<()> {
1874            decoder.debug_check_bounds::<Self>(offset);
1875            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1876                None => return Err(fidl::Error::NotNullable),
1877                Some(len) => len,
1878            };
1879            // Calling decoder.out_of_line_offset(0) is not allowed.
1880            if len == 0 {
1881                return Ok(());
1882            };
1883            depth.increment()?;
1884            let envelope_size = 8;
1885            let bytes_len = len * envelope_size;
1886            let offset = decoder.out_of_line_offset(bytes_len)?;
1887            // Decode the envelope for each type.
1888            let mut _next_ordinal_to_read = 0;
1889            let mut next_offset = offset;
1890            let end_offset = offset + bytes_len;
1891            _next_ordinal_to_read += 1;
1892            if next_offset >= end_offset {
1893                return Ok(());
1894            }
1895
1896            // Decode unknown envelopes for gaps in ordinals.
1897            while _next_ordinal_to_read < 1 {
1898                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1899                _next_ordinal_to_read += 1;
1900                next_offset += envelope_size;
1901            }
1902
1903            let next_out_of_line = decoder.next_out_of_line();
1904            let handles_before = decoder.remaining_handles();
1905            if let Some((inlined, num_bytes, num_handles)) =
1906                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1907            {
1908                let member_inline_size =
1909                    <Severity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1910                if inlined != (member_inline_size <= 4) {
1911                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1912                }
1913                let inner_offset;
1914                let mut inner_depth = depth.clone();
1915                if inlined {
1916                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1917                    inner_offset = next_offset;
1918                } else {
1919                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1920                    inner_depth.increment()?;
1921                }
1922                let val_ref =
1923                    self.min_severity.get_or_insert_with(|| fidl::new_empty!(Severity, D));
1924                fidl::decode!(Severity, D, val_ref, decoder, inner_offset, inner_depth)?;
1925                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1926                {
1927                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1928                }
1929                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1930                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1931                }
1932            }
1933
1934            next_offset += envelope_size;
1935
1936            // Decode the remaining unknown envelopes.
1937            while next_offset < end_offset {
1938                _next_ordinal_to_read += 1;
1939                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1940                next_offset += envelope_size;
1941            }
1942
1943            Ok(())
1944        }
1945    }
1946
1947    impl LogSettingsSetComponentInterestRequest {
1948        #[inline(always)]
1949        fn max_ordinal_present(&self) -> u64 {
1950            if let Some(_) = self.persist {
1951                return 2;
1952            }
1953            if let Some(_) = self.selectors {
1954                return 1;
1955            }
1956            0
1957        }
1958    }
1959
1960    impl fidl::encoding::ValueTypeMarker for LogSettingsSetComponentInterestRequest {
1961        type Borrowed<'a> = &'a Self;
1962        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1963            value
1964        }
1965    }
1966
1967    unsafe impl fidl::encoding::TypeMarker for LogSettingsSetComponentInterestRequest {
1968        type Owned = Self;
1969
1970        #[inline(always)]
1971        fn inline_align(_context: fidl::encoding::Context) -> usize {
1972            8
1973        }
1974
1975        #[inline(always)]
1976        fn inline_size(_context: fidl::encoding::Context) -> usize {
1977            16
1978        }
1979    }
1980
1981    unsafe impl<D: fidl::encoding::ResourceDialect>
1982        fidl::encoding::Encode<LogSettingsSetComponentInterestRequest, D>
1983        for &LogSettingsSetComponentInterestRequest
1984    {
1985        unsafe fn encode(
1986            self,
1987            encoder: &mut fidl::encoding::Encoder<'_, D>,
1988            offset: usize,
1989            mut depth: fidl::encoding::Depth,
1990        ) -> fidl::Result<()> {
1991            encoder.debug_check_bounds::<LogSettingsSetComponentInterestRequest>(offset);
1992            // Vector header
1993            let max_ordinal: u64 = self.max_ordinal_present();
1994            encoder.write_num(max_ordinal, offset);
1995            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1996            // Calling encoder.out_of_line_offset(0) is not allowed.
1997            if max_ordinal == 0 {
1998                return Ok(());
1999            }
2000            depth.increment()?;
2001            let envelope_size = 8;
2002            let bytes_len = max_ordinal as usize * envelope_size;
2003            #[allow(unused_variables)]
2004            let offset = encoder.out_of_line_offset(bytes_len);
2005            let mut _prev_end_offset: usize = 0;
2006            if 1 > max_ordinal {
2007                return Ok(());
2008            }
2009
2010            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2011            // are envelope_size bytes.
2012            let cur_offset: usize = (1 - 1) * envelope_size;
2013
2014            // Zero reserved fields.
2015            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2016
2017            // Safety:
2018            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2019            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2020            //   envelope_size bytes, there is always sufficient room.
2021            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LogInterestSelector, 64>, D>(
2022            self.selectors.as_ref().map(<fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::ValueTypeMarker>::borrow),
2023            encoder, offset + cur_offset, depth
2024        )?;
2025
2026            _prev_end_offset = cur_offset + envelope_size;
2027            if 2 > max_ordinal {
2028                return Ok(());
2029            }
2030
2031            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2032            // are envelope_size bytes.
2033            let cur_offset: usize = (2 - 1) * envelope_size;
2034
2035            // Zero reserved fields.
2036            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2037
2038            // Safety:
2039            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2040            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2041            //   envelope_size bytes, there is always sufficient room.
2042            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2043                self.persist.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2044                encoder,
2045                offset + cur_offset,
2046                depth,
2047            )?;
2048
2049            _prev_end_offset = cur_offset + envelope_size;
2050
2051            Ok(())
2052        }
2053    }
2054
2055    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2056        for LogSettingsSetComponentInterestRequest
2057    {
2058        #[inline(always)]
2059        fn new_empty() -> Self {
2060            Self::default()
2061        }
2062
2063        unsafe fn decode(
2064            &mut self,
2065            decoder: &mut fidl::encoding::Decoder<'_, D>,
2066            offset: usize,
2067            mut depth: fidl::encoding::Depth,
2068        ) -> fidl::Result<()> {
2069            decoder.debug_check_bounds::<Self>(offset);
2070            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2071                None => return Err(fidl::Error::NotNullable),
2072                Some(len) => len,
2073            };
2074            // Calling decoder.out_of_line_offset(0) is not allowed.
2075            if len == 0 {
2076                return Ok(());
2077            };
2078            depth.increment()?;
2079            let envelope_size = 8;
2080            let bytes_len = len * envelope_size;
2081            let offset = decoder.out_of_line_offset(bytes_len)?;
2082            // Decode the envelope for each type.
2083            let mut _next_ordinal_to_read = 0;
2084            let mut next_offset = offset;
2085            let end_offset = offset + bytes_len;
2086            _next_ordinal_to_read += 1;
2087            if next_offset >= end_offset {
2088                return Ok(());
2089            }
2090
2091            // Decode unknown envelopes for gaps in ordinals.
2092            while _next_ordinal_to_read < 1 {
2093                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2094                _next_ordinal_to_read += 1;
2095                next_offset += envelope_size;
2096            }
2097
2098            let next_out_of_line = decoder.next_out_of_line();
2099            let handles_before = decoder.remaining_handles();
2100            if let Some((inlined, num_bytes, num_handles)) =
2101                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2102            {
2103                let member_inline_size = <fidl::encoding::Vector<LogInterestSelector, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2104                if inlined != (member_inline_size <= 4) {
2105                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2106                }
2107                let inner_offset;
2108                let mut inner_depth = depth.clone();
2109                if inlined {
2110                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2111                    inner_offset = next_offset;
2112                } else {
2113                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2114                    inner_depth.increment()?;
2115                }
2116                let val_ref = self.selectors.get_or_insert_with(
2117                    || fidl::new_empty!(fidl::encoding::Vector<LogInterestSelector, 64>, D),
2118                );
2119                fidl::decode!(fidl::encoding::Vector<LogInterestSelector, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
2120                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2121                {
2122                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2123                }
2124                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2125                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2126                }
2127            }
2128
2129            next_offset += envelope_size;
2130            _next_ordinal_to_read += 1;
2131            if next_offset >= end_offset {
2132                return Ok(());
2133            }
2134
2135            // Decode unknown envelopes for gaps in ordinals.
2136            while _next_ordinal_to_read < 2 {
2137                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2138                _next_ordinal_to_read += 1;
2139                next_offset += envelope_size;
2140            }
2141
2142            let next_out_of_line = decoder.next_out_of_line();
2143            let handles_before = decoder.remaining_handles();
2144            if let Some((inlined, num_bytes, num_handles)) =
2145                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2146            {
2147                let member_inline_size =
2148                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2149                if inlined != (member_inline_size <= 4) {
2150                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2151                }
2152                let inner_offset;
2153                let mut inner_depth = depth.clone();
2154                if inlined {
2155                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2156                    inner_offset = next_offset;
2157                } else {
2158                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2159                    inner_depth.increment()?;
2160                }
2161                let val_ref = self.persist.get_or_insert_with(|| fidl::new_empty!(bool, D));
2162                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2164                {
2165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2166                }
2167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2169                }
2170            }
2171
2172            next_offset += envelope_size;
2173
2174            // Decode the remaining unknown envelopes.
2175            while next_offset < end_offset {
2176                _next_ordinal_to_read += 1;
2177                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2178                next_offset += envelope_size;
2179            }
2180
2181            Ok(())
2182        }
2183    }
2184
2185    impl LogStreamOptions {
2186        #[inline(always)]
2187        fn max_ordinal_present(&self) -> u64 {
2188            if let Some(_) = self.include_rolled_out {
2189                return 4;
2190            }
2191            if let Some(_) = self.include_component_url {
2192                return 3;
2193            }
2194            if let Some(_) = self.include_moniker {
2195                return 2;
2196            }
2197            if let Some(_) = self.mode {
2198                return 1;
2199            }
2200            0
2201        }
2202    }
2203
2204    impl fidl::encoding::ValueTypeMarker for LogStreamOptions {
2205        type Borrowed<'a> = &'a Self;
2206        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2207            value
2208        }
2209    }
2210
2211    unsafe impl fidl::encoding::TypeMarker for LogStreamOptions {
2212        type Owned = Self;
2213
2214        #[inline(always)]
2215        fn inline_align(_context: fidl::encoding::Context) -> usize {
2216            8
2217        }
2218
2219        #[inline(always)]
2220        fn inline_size(_context: fidl::encoding::Context) -> usize {
2221            16
2222        }
2223    }
2224
2225    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LogStreamOptions, D>
2226        for &LogStreamOptions
2227    {
2228        unsafe fn encode(
2229            self,
2230            encoder: &mut fidl::encoding::Encoder<'_, D>,
2231            offset: usize,
2232            mut depth: fidl::encoding::Depth,
2233        ) -> fidl::Result<()> {
2234            encoder.debug_check_bounds::<LogStreamOptions>(offset);
2235            // Vector header
2236            let max_ordinal: u64 = self.max_ordinal_present();
2237            encoder.write_num(max_ordinal, offset);
2238            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2239            // Calling encoder.out_of_line_offset(0) is not allowed.
2240            if max_ordinal == 0 {
2241                return Ok(());
2242            }
2243            depth.increment()?;
2244            let envelope_size = 8;
2245            let bytes_len = max_ordinal as usize * envelope_size;
2246            #[allow(unused_variables)]
2247            let offset = encoder.out_of_line_offset(bytes_len);
2248            let mut _prev_end_offset: usize = 0;
2249            if 1 > max_ordinal {
2250                return Ok(());
2251            }
2252
2253            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2254            // are envelope_size bytes.
2255            let cur_offset: usize = (1 - 1) * envelope_size;
2256
2257            // Zero reserved fields.
2258            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2259
2260            // Safety:
2261            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2262            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2263            //   envelope_size bytes, there is always sufficient room.
2264            fidl::encoding::encode_in_envelope_optional::<StreamMode, D>(
2265                self.mode.as_ref().map(<StreamMode as fidl::encoding::ValueTypeMarker>::borrow),
2266                encoder,
2267                offset + cur_offset,
2268                depth,
2269            )?;
2270
2271            _prev_end_offset = cur_offset + envelope_size;
2272            if 2 > max_ordinal {
2273                return Ok(());
2274            }
2275
2276            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2277            // are envelope_size bytes.
2278            let cur_offset: usize = (2 - 1) * envelope_size;
2279
2280            // Zero reserved fields.
2281            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2282
2283            // Safety:
2284            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2285            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2286            //   envelope_size bytes, there is always sufficient room.
2287            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2288                self.include_moniker
2289                    .as_ref()
2290                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2291                encoder,
2292                offset + cur_offset,
2293                depth,
2294            )?;
2295
2296            _prev_end_offset = cur_offset + envelope_size;
2297            if 3 > max_ordinal {
2298                return Ok(());
2299            }
2300
2301            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2302            // are envelope_size bytes.
2303            let cur_offset: usize = (3 - 1) * envelope_size;
2304
2305            // Zero reserved fields.
2306            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2307
2308            // Safety:
2309            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2310            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2311            //   envelope_size bytes, there is always sufficient room.
2312            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2313                self.include_component_url
2314                    .as_ref()
2315                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2316                encoder,
2317                offset + cur_offset,
2318                depth,
2319            )?;
2320
2321            _prev_end_offset = cur_offset + envelope_size;
2322            if 4 > max_ordinal {
2323                return Ok(());
2324            }
2325
2326            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2327            // are envelope_size bytes.
2328            let cur_offset: usize = (4 - 1) * envelope_size;
2329
2330            // Zero reserved fields.
2331            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2332
2333            // Safety:
2334            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2335            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2336            //   envelope_size bytes, there is always sufficient room.
2337            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2338                self.include_rolled_out
2339                    .as_ref()
2340                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2341                encoder,
2342                offset + cur_offset,
2343                depth,
2344            )?;
2345
2346            _prev_end_offset = cur_offset + envelope_size;
2347
2348            Ok(())
2349        }
2350    }
2351
2352    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LogStreamOptions {
2353        #[inline(always)]
2354        fn new_empty() -> Self {
2355            Self::default()
2356        }
2357
2358        unsafe fn decode(
2359            &mut self,
2360            decoder: &mut fidl::encoding::Decoder<'_, D>,
2361            offset: usize,
2362            mut depth: fidl::encoding::Depth,
2363        ) -> fidl::Result<()> {
2364            decoder.debug_check_bounds::<Self>(offset);
2365            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2366                None => return Err(fidl::Error::NotNullable),
2367                Some(len) => len,
2368            };
2369            // Calling decoder.out_of_line_offset(0) is not allowed.
2370            if len == 0 {
2371                return Ok(());
2372            };
2373            depth.increment()?;
2374            let envelope_size = 8;
2375            let bytes_len = len * envelope_size;
2376            let offset = decoder.out_of_line_offset(bytes_len)?;
2377            // Decode the envelope for each type.
2378            let mut _next_ordinal_to_read = 0;
2379            let mut next_offset = offset;
2380            let end_offset = offset + bytes_len;
2381            _next_ordinal_to_read += 1;
2382            if next_offset >= end_offset {
2383                return Ok(());
2384            }
2385
2386            // Decode unknown envelopes for gaps in ordinals.
2387            while _next_ordinal_to_read < 1 {
2388                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2389                _next_ordinal_to_read += 1;
2390                next_offset += envelope_size;
2391            }
2392
2393            let next_out_of_line = decoder.next_out_of_line();
2394            let handles_before = decoder.remaining_handles();
2395            if let Some((inlined, num_bytes, num_handles)) =
2396                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2397            {
2398                let member_inline_size =
2399                    <StreamMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2400                if inlined != (member_inline_size <= 4) {
2401                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2402                }
2403                let inner_offset;
2404                let mut inner_depth = depth.clone();
2405                if inlined {
2406                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2407                    inner_offset = next_offset;
2408                } else {
2409                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2410                    inner_depth.increment()?;
2411                }
2412                let val_ref = self.mode.get_or_insert_with(|| fidl::new_empty!(StreamMode, D));
2413                fidl::decode!(StreamMode, D, val_ref, decoder, inner_offset, inner_depth)?;
2414                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2415                {
2416                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2417                }
2418                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2419                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2420                }
2421            }
2422
2423            next_offset += envelope_size;
2424            _next_ordinal_to_read += 1;
2425            if next_offset >= end_offset {
2426                return Ok(());
2427            }
2428
2429            // Decode unknown envelopes for gaps in ordinals.
2430            while _next_ordinal_to_read < 2 {
2431                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2432                _next_ordinal_to_read += 1;
2433                next_offset += envelope_size;
2434            }
2435
2436            let next_out_of_line = decoder.next_out_of_line();
2437            let handles_before = decoder.remaining_handles();
2438            if let Some((inlined, num_bytes, num_handles)) =
2439                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2440            {
2441                let member_inline_size =
2442                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2443                if inlined != (member_inline_size <= 4) {
2444                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2445                }
2446                let inner_offset;
2447                let mut inner_depth = depth.clone();
2448                if inlined {
2449                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2450                    inner_offset = next_offset;
2451                } else {
2452                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2453                    inner_depth.increment()?;
2454                }
2455                let val_ref = self.include_moniker.get_or_insert_with(|| fidl::new_empty!(bool, D));
2456                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2458                {
2459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2460                }
2461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2463                }
2464            }
2465
2466            next_offset += envelope_size;
2467            _next_ordinal_to_read += 1;
2468            if next_offset >= end_offset {
2469                return Ok(());
2470            }
2471
2472            // Decode unknown envelopes for gaps in ordinals.
2473            while _next_ordinal_to_read < 3 {
2474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2475                _next_ordinal_to_read += 1;
2476                next_offset += envelope_size;
2477            }
2478
2479            let next_out_of_line = decoder.next_out_of_line();
2480            let handles_before = decoder.remaining_handles();
2481            if let Some((inlined, num_bytes, num_handles)) =
2482                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2483            {
2484                let member_inline_size =
2485                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2486                if inlined != (member_inline_size <= 4) {
2487                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2488                }
2489                let inner_offset;
2490                let mut inner_depth = depth.clone();
2491                if inlined {
2492                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2493                    inner_offset = next_offset;
2494                } else {
2495                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2496                    inner_depth.increment()?;
2497                }
2498                let val_ref =
2499                    self.include_component_url.get_or_insert_with(|| fidl::new_empty!(bool, D));
2500                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2501                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2502                {
2503                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2504                }
2505                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2506                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2507                }
2508            }
2509
2510            next_offset += envelope_size;
2511            _next_ordinal_to_read += 1;
2512            if next_offset >= end_offset {
2513                return Ok(());
2514            }
2515
2516            // Decode unknown envelopes for gaps in ordinals.
2517            while _next_ordinal_to_read < 4 {
2518                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2519                _next_ordinal_to_read += 1;
2520                next_offset += envelope_size;
2521            }
2522
2523            let next_out_of_line = decoder.next_out_of_line();
2524            let handles_before = decoder.remaining_handles();
2525            if let Some((inlined, num_bytes, num_handles)) =
2526                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2527            {
2528                let member_inline_size =
2529                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2530                if inlined != (member_inline_size <= 4) {
2531                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2532                }
2533                let inner_offset;
2534                let mut inner_depth = depth.clone();
2535                if inlined {
2536                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2537                    inner_offset = next_offset;
2538                } else {
2539                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2540                    inner_depth.increment()?;
2541                }
2542                let val_ref =
2543                    self.include_rolled_out.get_or_insert_with(|| fidl::new_empty!(bool, D));
2544                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2545                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2546                {
2547                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2548                }
2549                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2550                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2551                }
2552            }
2553
2554            next_offset += envelope_size;
2555
2556            // Decode the remaining unknown envelopes.
2557            while next_offset < end_offset {
2558                _next_ordinal_to_read += 1;
2559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2560                next_offset += envelope_size;
2561            }
2562
2563            Ok(())
2564        }
2565    }
2566
2567    impl PerformanceConfiguration {
2568        #[inline(always)]
2569        fn max_ordinal_present(&self) -> u64 {
2570            if let Some(_) = self.batch_retrieval_timeout_seconds {
2571                return 2;
2572            }
2573            if let Some(_) = self.max_aggregate_content_size_bytes {
2574                return 1;
2575            }
2576            0
2577        }
2578    }
2579
2580    impl fidl::encoding::ValueTypeMarker for PerformanceConfiguration {
2581        type Borrowed<'a> = &'a Self;
2582        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2583            value
2584        }
2585    }
2586
2587    unsafe impl fidl::encoding::TypeMarker for PerformanceConfiguration {
2588        type Owned = Self;
2589
2590        #[inline(always)]
2591        fn inline_align(_context: fidl::encoding::Context) -> usize {
2592            8
2593        }
2594
2595        #[inline(always)]
2596        fn inline_size(_context: fidl::encoding::Context) -> usize {
2597            16
2598        }
2599    }
2600
2601    unsafe impl<D: fidl::encoding::ResourceDialect>
2602        fidl::encoding::Encode<PerformanceConfiguration, D> for &PerformanceConfiguration
2603    {
2604        unsafe fn encode(
2605            self,
2606            encoder: &mut fidl::encoding::Encoder<'_, D>,
2607            offset: usize,
2608            mut depth: fidl::encoding::Depth,
2609        ) -> fidl::Result<()> {
2610            encoder.debug_check_bounds::<PerformanceConfiguration>(offset);
2611            // Vector header
2612            let max_ordinal: u64 = self.max_ordinal_present();
2613            encoder.write_num(max_ordinal, offset);
2614            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2615            // Calling encoder.out_of_line_offset(0) is not allowed.
2616            if max_ordinal == 0 {
2617                return Ok(());
2618            }
2619            depth.increment()?;
2620            let envelope_size = 8;
2621            let bytes_len = max_ordinal as usize * envelope_size;
2622            #[allow(unused_variables)]
2623            let offset = encoder.out_of_line_offset(bytes_len);
2624            let mut _prev_end_offset: usize = 0;
2625            if 1 > max_ordinal {
2626                return Ok(());
2627            }
2628
2629            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2630            // are envelope_size bytes.
2631            let cur_offset: usize = (1 - 1) * envelope_size;
2632
2633            // Zero reserved fields.
2634            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2635
2636            // Safety:
2637            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2638            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2639            //   envelope_size bytes, there is always sufficient room.
2640            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2641                self.max_aggregate_content_size_bytes
2642                    .as_ref()
2643                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2644                encoder,
2645                offset + cur_offset,
2646                depth,
2647            )?;
2648
2649            _prev_end_offset = cur_offset + envelope_size;
2650            if 2 > max_ordinal {
2651                return Ok(());
2652            }
2653
2654            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2655            // are envelope_size bytes.
2656            let cur_offset: usize = (2 - 1) * envelope_size;
2657
2658            // Zero reserved fields.
2659            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2660
2661            // Safety:
2662            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2663            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2664            //   envelope_size bytes, there is always sufficient room.
2665            fidl::encoding::encode_in_envelope_optional::<i64, D>(
2666                self.batch_retrieval_timeout_seconds
2667                    .as_ref()
2668                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2669                encoder,
2670                offset + cur_offset,
2671                depth,
2672            )?;
2673
2674            _prev_end_offset = cur_offset + envelope_size;
2675
2676            Ok(())
2677        }
2678    }
2679
2680    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2681        for PerformanceConfiguration
2682    {
2683        #[inline(always)]
2684        fn new_empty() -> Self {
2685            Self::default()
2686        }
2687
2688        unsafe fn decode(
2689            &mut self,
2690            decoder: &mut fidl::encoding::Decoder<'_, D>,
2691            offset: usize,
2692            mut depth: fidl::encoding::Depth,
2693        ) -> fidl::Result<()> {
2694            decoder.debug_check_bounds::<Self>(offset);
2695            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2696                None => return Err(fidl::Error::NotNullable),
2697                Some(len) => len,
2698            };
2699            // Calling decoder.out_of_line_offset(0) is not allowed.
2700            if len == 0 {
2701                return Ok(());
2702            };
2703            depth.increment()?;
2704            let envelope_size = 8;
2705            let bytes_len = len * envelope_size;
2706            let offset = decoder.out_of_line_offset(bytes_len)?;
2707            // Decode the envelope for each type.
2708            let mut _next_ordinal_to_read = 0;
2709            let mut next_offset = offset;
2710            let end_offset = offset + bytes_len;
2711            _next_ordinal_to_read += 1;
2712            if next_offset >= end_offset {
2713                return Ok(());
2714            }
2715
2716            // Decode unknown envelopes for gaps in ordinals.
2717            while _next_ordinal_to_read < 1 {
2718                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2719                _next_ordinal_to_read += 1;
2720                next_offset += envelope_size;
2721            }
2722
2723            let next_out_of_line = decoder.next_out_of_line();
2724            let handles_before = decoder.remaining_handles();
2725            if let Some((inlined, num_bytes, num_handles)) =
2726                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2727            {
2728                let member_inline_size =
2729                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2730                if inlined != (member_inline_size <= 4) {
2731                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2732                }
2733                let inner_offset;
2734                let mut inner_depth = depth.clone();
2735                if inlined {
2736                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2737                    inner_offset = next_offset;
2738                } else {
2739                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2740                    inner_depth.increment()?;
2741                }
2742                let val_ref = self
2743                    .max_aggregate_content_size_bytes
2744                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
2745                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2746                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2747                {
2748                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2749                }
2750                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2751                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2752                }
2753            }
2754
2755            next_offset += envelope_size;
2756            _next_ordinal_to_read += 1;
2757            if next_offset >= end_offset {
2758                return Ok(());
2759            }
2760
2761            // Decode unknown envelopes for gaps in ordinals.
2762            while _next_ordinal_to_read < 2 {
2763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2764                _next_ordinal_to_read += 1;
2765                next_offset += envelope_size;
2766            }
2767
2768            let next_out_of_line = decoder.next_out_of_line();
2769            let handles_before = decoder.remaining_handles();
2770            if let Some((inlined, num_bytes, num_handles)) =
2771                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2772            {
2773                let member_inline_size =
2774                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2775                if inlined != (member_inline_size <= 4) {
2776                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2777                }
2778                let inner_offset;
2779                let mut inner_depth = depth.clone();
2780                if inlined {
2781                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2782                    inner_offset = next_offset;
2783                } else {
2784                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2785                    inner_depth.increment()?;
2786                }
2787                let val_ref = self
2788                    .batch_retrieval_timeout_seconds
2789                    .get_or_insert_with(|| fidl::new_empty!(i64, D));
2790                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
2791                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2792                {
2793                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2794                }
2795                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2796                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2797                }
2798            }
2799
2800            next_offset += envelope_size;
2801
2802            // Decode the remaining unknown envelopes.
2803            while next_offset < end_offset {
2804                _next_ordinal_to_read += 1;
2805                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2806                next_offset += envelope_size;
2807            }
2808
2809            Ok(())
2810        }
2811    }
2812
2813    impl Selector {
2814        #[inline(always)]
2815        fn max_ordinal_present(&self) -> u64 {
2816            if let Some(_) = self.tree_names {
2817                return 3;
2818            }
2819            if let Some(_) = self.tree_selector {
2820                return 2;
2821            }
2822            if let Some(_) = self.component_selector {
2823                return 1;
2824            }
2825            0
2826        }
2827    }
2828
2829    impl fidl::encoding::ValueTypeMarker for Selector {
2830        type Borrowed<'a> = &'a Self;
2831        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2832            value
2833        }
2834    }
2835
2836    unsafe impl fidl::encoding::TypeMarker for Selector {
2837        type Owned = Self;
2838
2839        #[inline(always)]
2840        fn inline_align(_context: fidl::encoding::Context) -> usize {
2841            8
2842        }
2843
2844        #[inline(always)]
2845        fn inline_size(_context: fidl::encoding::Context) -> usize {
2846            16
2847        }
2848    }
2849
2850    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Selector, D> for &Selector {
2851        unsafe fn encode(
2852            self,
2853            encoder: &mut fidl::encoding::Encoder<'_, D>,
2854            offset: usize,
2855            mut depth: fidl::encoding::Depth,
2856        ) -> fidl::Result<()> {
2857            encoder.debug_check_bounds::<Selector>(offset);
2858            // Vector header
2859            let max_ordinal: u64 = self.max_ordinal_present();
2860            encoder.write_num(max_ordinal, offset);
2861            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2862            // Calling encoder.out_of_line_offset(0) is not allowed.
2863            if max_ordinal == 0 {
2864                return Ok(());
2865            }
2866            depth.increment()?;
2867            let envelope_size = 8;
2868            let bytes_len = max_ordinal as usize * envelope_size;
2869            #[allow(unused_variables)]
2870            let offset = encoder.out_of_line_offset(bytes_len);
2871            let mut _prev_end_offset: usize = 0;
2872            if 1 > max_ordinal {
2873                return Ok(());
2874            }
2875
2876            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2877            // are envelope_size bytes.
2878            let cur_offset: usize = (1 - 1) * envelope_size;
2879
2880            // Zero reserved fields.
2881            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2882
2883            // Safety:
2884            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2885            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2886            //   envelope_size bytes, there is always sufficient room.
2887            fidl::encoding::encode_in_envelope_optional::<ComponentSelector, D>(
2888                self.component_selector
2889                    .as_ref()
2890                    .map(<ComponentSelector as fidl::encoding::ValueTypeMarker>::borrow),
2891                encoder,
2892                offset + cur_offset,
2893                depth,
2894            )?;
2895
2896            _prev_end_offset = cur_offset + envelope_size;
2897            if 2 > max_ordinal {
2898                return Ok(());
2899            }
2900
2901            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2902            // are envelope_size bytes.
2903            let cur_offset: usize = (2 - 1) * envelope_size;
2904
2905            // Zero reserved fields.
2906            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2907
2908            // Safety:
2909            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2910            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2911            //   envelope_size bytes, there is always sufficient room.
2912            fidl::encoding::encode_in_envelope_optional::<TreeSelector, D>(
2913                self.tree_selector
2914                    .as_ref()
2915                    .map(<TreeSelector as fidl::encoding::ValueTypeMarker>::borrow),
2916                encoder,
2917                offset + cur_offset,
2918                depth,
2919            )?;
2920
2921            _prev_end_offset = cur_offset + envelope_size;
2922            if 3 > max_ordinal {
2923                return Ok(());
2924            }
2925
2926            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2927            // are envelope_size bytes.
2928            let cur_offset: usize = (3 - 1) * envelope_size;
2929
2930            // Zero reserved fields.
2931            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2932
2933            // Safety:
2934            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2935            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2936            //   envelope_size bytes, there is always sufficient room.
2937            fidl::encoding::encode_in_envelope_optional::<TreeNames, D>(
2938                self.tree_names
2939                    .as_ref()
2940                    .map(<TreeNames as fidl::encoding::ValueTypeMarker>::borrow),
2941                encoder,
2942                offset + cur_offset,
2943                depth,
2944            )?;
2945
2946            _prev_end_offset = cur_offset + envelope_size;
2947
2948            Ok(())
2949        }
2950    }
2951
2952    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Selector {
2953        #[inline(always)]
2954        fn new_empty() -> Self {
2955            Self::default()
2956        }
2957
2958        unsafe fn decode(
2959            &mut self,
2960            decoder: &mut fidl::encoding::Decoder<'_, D>,
2961            offset: usize,
2962            mut depth: fidl::encoding::Depth,
2963        ) -> fidl::Result<()> {
2964            decoder.debug_check_bounds::<Self>(offset);
2965            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2966                None => return Err(fidl::Error::NotNullable),
2967                Some(len) => len,
2968            };
2969            // Calling decoder.out_of_line_offset(0) is not allowed.
2970            if len == 0 {
2971                return Ok(());
2972            };
2973            depth.increment()?;
2974            let envelope_size = 8;
2975            let bytes_len = len * envelope_size;
2976            let offset = decoder.out_of_line_offset(bytes_len)?;
2977            // Decode the envelope for each type.
2978            let mut _next_ordinal_to_read = 0;
2979            let mut next_offset = offset;
2980            let end_offset = offset + bytes_len;
2981            _next_ordinal_to_read += 1;
2982            if next_offset >= end_offset {
2983                return Ok(());
2984            }
2985
2986            // Decode unknown envelopes for gaps in ordinals.
2987            while _next_ordinal_to_read < 1 {
2988                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2989                _next_ordinal_to_read += 1;
2990                next_offset += envelope_size;
2991            }
2992
2993            let next_out_of_line = decoder.next_out_of_line();
2994            let handles_before = decoder.remaining_handles();
2995            if let Some((inlined, num_bytes, num_handles)) =
2996                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2997            {
2998                let member_inline_size =
2999                    <ComponentSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3000                if inlined != (member_inline_size <= 4) {
3001                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3002                }
3003                let inner_offset;
3004                let mut inner_depth = depth.clone();
3005                if inlined {
3006                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3007                    inner_offset = next_offset;
3008                } else {
3009                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3010                    inner_depth.increment()?;
3011                }
3012                let val_ref = self
3013                    .component_selector
3014                    .get_or_insert_with(|| fidl::new_empty!(ComponentSelector, D));
3015                fidl::decode!(ComponentSelector, D, val_ref, decoder, inner_offset, inner_depth)?;
3016                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3017                {
3018                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3019                }
3020                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3021                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3022                }
3023            }
3024
3025            next_offset += envelope_size;
3026            _next_ordinal_to_read += 1;
3027            if next_offset >= end_offset {
3028                return Ok(());
3029            }
3030
3031            // Decode unknown envelopes for gaps in ordinals.
3032            while _next_ordinal_to_read < 2 {
3033                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3034                _next_ordinal_to_read += 1;
3035                next_offset += envelope_size;
3036            }
3037
3038            let next_out_of_line = decoder.next_out_of_line();
3039            let handles_before = decoder.remaining_handles();
3040            if let Some((inlined, num_bytes, num_handles)) =
3041                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3042            {
3043                let member_inline_size =
3044                    <TreeSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3045                if inlined != (member_inline_size <= 4) {
3046                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3047                }
3048                let inner_offset;
3049                let mut inner_depth = depth.clone();
3050                if inlined {
3051                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3052                    inner_offset = next_offset;
3053                } else {
3054                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3055                    inner_depth.increment()?;
3056                }
3057                let val_ref =
3058                    self.tree_selector.get_or_insert_with(|| fidl::new_empty!(TreeSelector, D));
3059                fidl::decode!(TreeSelector, D, val_ref, decoder, inner_offset, inner_depth)?;
3060                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3061                {
3062                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3063                }
3064                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3065                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3066                }
3067            }
3068
3069            next_offset += envelope_size;
3070            _next_ordinal_to_read += 1;
3071            if next_offset >= end_offset {
3072                return Ok(());
3073            }
3074
3075            // Decode unknown envelopes for gaps in ordinals.
3076            while _next_ordinal_to_read < 3 {
3077                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3078                _next_ordinal_to_read += 1;
3079                next_offset += envelope_size;
3080            }
3081
3082            let next_out_of_line = decoder.next_out_of_line();
3083            let handles_before = decoder.remaining_handles();
3084            if let Some((inlined, num_bytes, num_handles)) =
3085                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3086            {
3087                let member_inline_size =
3088                    <TreeNames as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3089                if inlined != (member_inline_size <= 4) {
3090                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3091                }
3092                let inner_offset;
3093                let mut inner_depth = depth.clone();
3094                if inlined {
3095                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3096                    inner_offset = next_offset;
3097                } else {
3098                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3099                    inner_depth.increment()?;
3100                }
3101                let val_ref = self.tree_names.get_or_insert_with(|| fidl::new_empty!(TreeNames, D));
3102                fidl::decode!(TreeNames, D, val_ref, decoder, inner_offset, inner_depth)?;
3103                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3104                {
3105                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3106                }
3107                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3108                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3109                }
3110            }
3111
3112            next_offset += envelope_size;
3113
3114            // Decode the remaining unknown envelopes.
3115            while next_offset < end_offset {
3116                _next_ordinal_to_read += 1;
3117                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3118                next_offset += envelope_size;
3119            }
3120
3121            Ok(())
3122        }
3123    }
3124
3125    impl StreamParameters {
3126        #[inline(always)]
3127        fn max_ordinal_present(&self) -> u64 {
3128            if let Some(_) = self.performance_configuration {
3129                return 6;
3130            }
3131            if let Some(_) = self.batch_retrieval_timeout_seconds {
3132                return 5;
3133            }
3134            if let Some(_) = self.client_selector_configuration {
3135                return 4;
3136            }
3137            if let Some(_) = self.format {
3138                return 3;
3139            }
3140            if let Some(_) = self.stream_mode {
3141                return 2;
3142            }
3143            if let Some(_) = self.data_type {
3144                return 1;
3145            }
3146            0
3147        }
3148    }
3149
3150    impl fidl::encoding::ValueTypeMarker for StreamParameters {
3151        type Borrowed<'a> = &'a Self;
3152        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3153            value
3154        }
3155    }
3156
3157    unsafe impl fidl::encoding::TypeMarker for StreamParameters {
3158        type Owned = Self;
3159
3160        #[inline(always)]
3161        fn inline_align(_context: fidl::encoding::Context) -> usize {
3162            8
3163        }
3164
3165        #[inline(always)]
3166        fn inline_size(_context: fidl::encoding::Context) -> usize {
3167            16
3168        }
3169    }
3170
3171    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StreamParameters, D>
3172        for &StreamParameters
3173    {
3174        unsafe fn encode(
3175            self,
3176            encoder: &mut fidl::encoding::Encoder<'_, D>,
3177            offset: usize,
3178            mut depth: fidl::encoding::Depth,
3179        ) -> fidl::Result<()> {
3180            encoder.debug_check_bounds::<StreamParameters>(offset);
3181            // Vector header
3182            let max_ordinal: u64 = self.max_ordinal_present();
3183            encoder.write_num(max_ordinal, offset);
3184            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3185            // Calling encoder.out_of_line_offset(0) is not allowed.
3186            if max_ordinal == 0 {
3187                return Ok(());
3188            }
3189            depth.increment()?;
3190            let envelope_size = 8;
3191            let bytes_len = max_ordinal as usize * envelope_size;
3192            #[allow(unused_variables)]
3193            let offset = encoder.out_of_line_offset(bytes_len);
3194            let mut _prev_end_offset: usize = 0;
3195            if 1 > max_ordinal {
3196                return Ok(());
3197            }
3198
3199            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3200            // are envelope_size bytes.
3201            let cur_offset: usize = (1 - 1) * envelope_size;
3202
3203            // Zero reserved fields.
3204            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3205
3206            // Safety:
3207            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3208            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3209            //   envelope_size bytes, there is always sufficient room.
3210            fidl::encoding::encode_in_envelope_optional::<DataType, D>(
3211                self.data_type.as_ref().map(<DataType as fidl::encoding::ValueTypeMarker>::borrow),
3212                encoder,
3213                offset + cur_offset,
3214                depth,
3215            )?;
3216
3217            _prev_end_offset = cur_offset + envelope_size;
3218            if 2 > max_ordinal {
3219                return Ok(());
3220            }
3221
3222            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3223            // are envelope_size bytes.
3224            let cur_offset: usize = (2 - 1) * envelope_size;
3225
3226            // Zero reserved fields.
3227            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3228
3229            // Safety:
3230            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3231            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3232            //   envelope_size bytes, there is always sufficient room.
3233            fidl::encoding::encode_in_envelope_optional::<StreamMode, D>(
3234                self.stream_mode
3235                    .as_ref()
3236                    .map(<StreamMode as fidl::encoding::ValueTypeMarker>::borrow),
3237                encoder,
3238                offset + cur_offset,
3239                depth,
3240            )?;
3241
3242            _prev_end_offset = cur_offset + envelope_size;
3243            if 3 > max_ordinal {
3244                return Ok(());
3245            }
3246
3247            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3248            // are envelope_size bytes.
3249            let cur_offset: usize = (3 - 1) * envelope_size;
3250
3251            // Zero reserved fields.
3252            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3253
3254            // Safety:
3255            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3256            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3257            //   envelope_size bytes, there is always sufficient room.
3258            fidl::encoding::encode_in_envelope_optional::<Format, D>(
3259                self.format.as_ref().map(<Format as fidl::encoding::ValueTypeMarker>::borrow),
3260                encoder,
3261                offset + cur_offset,
3262                depth,
3263            )?;
3264
3265            _prev_end_offset = cur_offset + envelope_size;
3266            if 4 > max_ordinal {
3267                return Ok(());
3268            }
3269
3270            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3271            // are envelope_size bytes.
3272            let cur_offset: usize = (4 - 1) * envelope_size;
3273
3274            // Zero reserved fields.
3275            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3276
3277            // Safety:
3278            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3279            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3280            //   envelope_size bytes, there is always sufficient room.
3281            fidl::encoding::encode_in_envelope_optional::<ClientSelectorConfiguration, D>(
3282                self.client_selector_configuration
3283                    .as_ref()
3284                    .map(<ClientSelectorConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3285                encoder,
3286                offset + cur_offset,
3287                depth,
3288            )?;
3289
3290            _prev_end_offset = cur_offset + envelope_size;
3291            if 5 > max_ordinal {
3292                return Ok(());
3293            }
3294
3295            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3296            // are envelope_size bytes.
3297            let cur_offset: usize = (5 - 1) * envelope_size;
3298
3299            // Zero reserved fields.
3300            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3301
3302            // Safety:
3303            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3304            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3305            //   envelope_size bytes, there is always sufficient room.
3306            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3307                self.batch_retrieval_timeout_seconds
3308                    .as_ref()
3309                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3310                encoder,
3311                offset + cur_offset,
3312                depth,
3313            )?;
3314
3315            _prev_end_offset = cur_offset + envelope_size;
3316            if 6 > max_ordinal {
3317                return Ok(());
3318            }
3319
3320            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3321            // are envelope_size bytes.
3322            let cur_offset: usize = (6 - 1) * envelope_size;
3323
3324            // Zero reserved fields.
3325            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3326
3327            // Safety:
3328            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3329            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3330            //   envelope_size bytes, there is always sufficient room.
3331            fidl::encoding::encode_in_envelope_optional::<PerformanceConfiguration, D>(
3332                self.performance_configuration
3333                    .as_ref()
3334                    .map(<PerformanceConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3335                encoder,
3336                offset + cur_offset,
3337                depth,
3338            )?;
3339
3340            _prev_end_offset = cur_offset + envelope_size;
3341
3342            Ok(())
3343        }
3344    }
3345
3346    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StreamParameters {
3347        #[inline(always)]
3348        fn new_empty() -> Self {
3349            Self::default()
3350        }
3351
3352        unsafe fn decode(
3353            &mut self,
3354            decoder: &mut fidl::encoding::Decoder<'_, D>,
3355            offset: usize,
3356            mut depth: fidl::encoding::Depth,
3357        ) -> fidl::Result<()> {
3358            decoder.debug_check_bounds::<Self>(offset);
3359            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3360                None => return Err(fidl::Error::NotNullable),
3361                Some(len) => len,
3362            };
3363            // Calling decoder.out_of_line_offset(0) is not allowed.
3364            if len == 0 {
3365                return Ok(());
3366            };
3367            depth.increment()?;
3368            let envelope_size = 8;
3369            let bytes_len = len * envelope_size;
3370            let offset = decoder.out_of_line_offset(bytes_len)?;
3371            // Decode the envelope for each type.
3372            let mut _next_ordinal_to_read = 0;
3373            let mut next_offset = offset;
3374            let end_offset = offset + bytes_len;
3375            _next_ordinal_to_read += 1;
3376            if next_offset >= end_offset {
3377                return Ok(());
3378            }
3379
3380            // Decode unknown envelopes for gaps in ordinals.
3381            while _next_ordinal_to_read < 1 {
3382                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3383                _next_ordinal_to_read += 1;
3384                next_offset += envelope_size;
3385            }
3386
3387            let next_out_of_line = decoder.next_out_of_line();
3388            let handles_before = decoder.remaining_handles();
3389            if let Some((inlined, num_bytes, num_handles)) =
3390                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3391            {
3392                let member_inline_size =
3393                    <DataType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3394                if inlined != (member_inline_size <= 4) {
3395                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3396                }
3397                let inner_offset;
3398                let mut inner_depth = depth.clone();
3399                if inlined {
3400                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3401                    inner_offset = next_offset;
3402                } else {
3403                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3404                    inner_depth.increment()?;
3405                }
3406                let val_ref = self.data_type.get_or_insert_with(|| fidl::new_empty!(DataType, D));
3407                fidl::decode!(DataType, D, val_ref, decoder, inner_offset, inner_depth)?;
3408                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3409                {
3410                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3411                }
3412                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3413                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3414                }
3415            }
3416
3417            next_offset += envelope_size;
3418            _next_ordinal_to_read += 1;
3419            if next_offset >= end_offset {
3420                return Ok(());
3421            }
3422
3423            // Decode unknown envelopes for gaps in ordinals.
3424            while _next_ordinal_to_read < 2 {
3425                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3426                _next_ordinal_to_read += 1;
3427                next_offset += envelope_size;
3428            }
3429
3430            let next_out_of_line = decoder.next_out_of_line();
3431            let handles_before = decoder.remaining_handles();
3432            if let Some((inlined, num_bytes, num_handles)) =
3433                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3434            {
3435                let member_inline_size =
3436                    <StreamMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3437                if inlined != (member_inline_size <= 4) {
3438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3439                }
3440                let inner_offset;
3441                let mut inner_depth = depth.clone();
3442                if inlined {
3443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3444                    inner_offset = next_offset;
3445                } else {
3446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3447                    inner_depth.increment()?;
3448                }
3449                let val_ref =
3450                    self.stream_mode.get_or_insert_with(|| fidl::new_empty!(StreamMode, D));
3451                fidl::decode!(StreamMode, D, val_ref, decoder, inner_offset, inner_depth)?;
3452                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3453                {
3454                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3455                }
3456                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3457                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3458                }
3459            }
3460
3461            next_offset += envelope_size;
3462            _next_ordinal_to_read += 1;
3463            if next_offset >= end_offset {
3464                return Ok(());
3465            }
3466
3467            // Decode unknown envelopes for gaps in ordinals.
3468            while _next_ordinal_to_read < 3 {
3469                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3470                _next_ordinal_to_read += 1;
3471                next_offset += envelope_size;
3472            }
3473
3474            let next_out_of_line = decoder.next_out_of_line();
3475            let handles_before = decoder.remaining_handles();
3476            if let Some((inlined, num_bytes, num_handles)) =
3477                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3478            {
3479                let member_inline_size =
3480                    <Format as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3481                if inlined != (member_inline_size <= 4) {
3482                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3483                }
3484                let inner_offset;
3485                let mut inner_depth = depth.clone();
3486                if inlined {
3487                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3488                    inner_offset = next_offset;
3489                } else {
3490                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3491                    inner_depth.increment()?;
3492                }
3493                let val_ref = self.format.get_or_insert_with(|| fidl::new_empty!(Format, D));
3494                fidl::decode!(Format, D, val_ref, decoder, inner_offset, inner_depth)?;
3495                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3496                {
3497                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3498                }
3499                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3500                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3501                }
3502            }
3503
3504            next_offset += envelope_size;
3505            _next_ordinal_to_read += 1;
3506            if next_offset >= end_offset {
3507                return Ok(());
3508            }
3509
3510            // Decode unknown envelopes for gaps in ordinals.
3511            while _next_ordinal_to_read < 4 {
3512                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3513                _next_ordinal_to_read += 1;
3514                next_offset += envelope_size;
3515            }
3516
3517            let next_out_of_line = decoder.next_out_of_line();
3518            let handles_before = decoder.remaining_handles();
3519            if let Some((inlined, num_bytes, num_handles)) =
3520                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3521            {
3522                let member_inline_size =
3523                    <ClientSelectorConfiguration as fidl::encoding::TypeMarker>::inline_size(
3524                        decoder.context,
3525                    );
3526                if inlined != (member_inline_size <= 4) {
3527                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3528                }
3529                let inner_offset;
3530                let mut inner_depth = depth.clone();
3531                if inlined {
3532                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3533                    inner_offset = next_offset;
3534                } else {
3535                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3536                    inner_depth.increment()?;
3537                }
3538                let val_ref = self
3539                    .client_selector_configuration
3540                    .get_or_insert_with(|| fidl::new_empty!(ClientSelectorConfiguration, D));
3541                fidl::decode!(
3542                    ClientSelectorConfiguration,
3543                    D,
3544                    val_ref,
3545                    decoder,
3546                    inner_offset,
3547                    inner_depth
3548                )?;
3549                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3550                {
3551                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3552                }
3553                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3554                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3555                }
3556            }
3557
3558            next_offset += envelope_size;
3559            _next_ordinal_to_read += 1;
3560            if next_offset >= end_offset {
3561                return Ok(());
3562            }
3563
3564            // Decode unknown envelopes for gaps in ordinals.
3565            while _next_ordinal_to_read < 5 {
3566                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3567                _next_ordinal_to_read += 1;
3568                next_offset += envelope_size;
3569            }
3570
3571            let next_out_of_line = decoder.next_out_of_line();
3572            let handles_before = decoder.remaining_handles();
3573            if let Some((inlined, num_bytes, num_handles)) =
3574                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3575            {
3576                let member_inline_size =
3577                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3578                if inlined != (member_inline_size <= 4) {
3579                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3580                }
3581                let inner_offset;
3582                let mut inner_depth = depth.clone();
3583                if inlined {
3584                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3585                    inner_offset = next_offset;
3586                } else {
3587                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3588                    inner_depth.increment()?;
3589                }
3590                let val_ref = self
3591                    .batch_retrieval_timeout_seconds
3592                    .get_or_insert_with(|| fidl::new_empty!(i64, D));
3593                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3594                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3595                {
3596                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3597                }
3598                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3599                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3600                }
3601            }
3602
3603            next_offset += envelope_size;
3604            _next_ordinal_to_read += 1;
3605            if next_offset >= end_offset {
3606                return Ok(());
3607            }
3608
3609            // Decode unknown envelopes for gaps in ordinals.
3610            while _next_ordinal_to_read < 6 {
3611                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3612                _next_ordinal_to_read += 1;
3613                next_offset += envelope_size;
3614            }
3615
3616            let next_out_of_line = decoder.next_out_of_line();
3617            let handles_before = decoder.remaining_handles();
3618            if let Some((inlined, num_bytes, num_handles)) =
3619                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3620            {
3621                let member_inline_size =
3622                    <PerformanceConfiguration as fidl::encoding::TypeMarker>::inline_size(
3623                        decoder.context,
3624                    );
3625                if inlined != (member_inline_size <= 4) {
3626                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3627                }
3628                let inner_offset;
3629                let mut inner_depth = depth.clone();
3630                if inlined {
3631                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3632                    inner_offset = next_offset;
3633                } else {
3634                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3635                    inner_depth.increment()?;
3636                }
3637                let val_ref = self
3638                    .performance_configuration
3639                    .get_or_insert_with(|| fidl::new_empty!(PerformanceConfiguration, D));
3640                fidl::decode!(
3641                    PerformanceConfiguration,
3642                    D,
3643                    val_ref,
3644                    decoder,
3645                    inner_offset,
3646                    inner_depth
3647                )?;
3648                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3649                {
3650                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3651                }
3652                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3653                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3654                }
3655            }
3656
3657            next_offset += envelope_size;
3658
3659            // Decode the remaining unknown envelopes.
3660            while next_offset < end_offset {
3661                _next_ordinal_to_read += 1;
3662                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3663                next_offset += envelope_size;
3664            }
3665
3666            Ok(())
3667        }
3668    }
3669
3670    impl fidl::encoding::ValueTypeMarker for ClientSelectorConfiguration {
3671        type Borrowed<'a> = &'a Self;
3672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673            value
3674        }
3675    }
3676
3677    unsafe impl fidl::encoding::TypeMarker for ClientSelectorConfiguration {
3678        type Owned = Self;
3679
3680        #[inline(always)]
3681        fn inline_align(_context: fidl::encoding::Context) -> usize {
3682            8
3683        }
3684
3685        #[inline(always)]
3686        fn inline_size(_context: fidl::encoding::Context) -> usize {
3687            16
3688        }
3689    }
3690
3691    unsafe impl<D: fidl::encoding::ResourceDialect>
3692        fidl::encoding::Encode<ClientSelectorConfiguration, D> for &ClientSelectorConfiguration
3693    {
3694        #[inline]
3695        unsafe fn encode(
3696            self,
3697            encoder: &mut fidl::encoding::Encoder<'_, D>,
3698            offset: usize,
3699            _depth: fidl::encoding::Depth,
3700        ) -> fidl::Result<()> {
3701            encoder.debug_check_bounds::<ClientSelectorConfiguration>(offset);
3702            encoder.write_num::<u64>(self.ordinal(), offset);
3703            match self {
3704            ClientSelectorConfiguration::Selectors(ref val) => {
3705                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<SelectorArgument>, D>(
3706                    <fidl::encoding::UnboundedVector<SelectorArgument> as fidl::encoding::ValueTypeMarker>::borrow(val),
3707                    encoder, offset + 8, _depth
3708                )
3709            }
3710            ClientSelectorConfiguration::SelectAll(ref val) => {
3711                fidl::encoding::encode_in_envelope::<bool, D>(
3712                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3713                    encoder, offset + 8, _depth
3714                )
3715            }
3716            ClientSelectorConfiguration::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
3717        }
3718        }
3719    }
3720
3721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3722        for ClientSelectorConfiguration
3723    {
3724        #[inline(always)]
3725        fn new_empty() -> Self {
3726            Self::__SourceBreaking { unknown_ordinal: 0 }
3727        }
3728
3729        #[inline]
3730        unsafe fn decode(
3731            &mut self,
3732            decoder: &mut fidl::encoding::Decoder<'_, D>,
3733            offset: usize,
3734            mut depth: fidl::encoding::Depth,
3735        ) -> fidl::Result<()> {
3736            decoder.debug_check_bounds::<Self>(offset);
3737            #[allow(unused_variables)]
3738            let next_out_of_line = decoder.next_out_of_line();
3739            let handles_before = decoder.remaining_handles();
3740            let (ordinal, inlined, num_bytes, num_handles) =
3741                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3742
3743            let member_inline_size = match ordinal {
3744            1 => <fidl::encoding::UnboundedVector<SelectorArgument> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3745            2 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3746            0 => return Err(fidl::Error::UnknownUnionTag),
3747            _ => num_bytes as usize,
3748        };
3749
3750            if inlined != (member_inline_size <= 4) {
3751                return Err(fidl::Error::InvalidInlineBitInEnvelope);
3752            }
3753            let _inner_offset;
3754            if inlined {
3755                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
3756                _inner_offset = offset + 8;
3757            } else {
3758                depth.increment()?;
3759                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3760            }
3761            match ordinal {
3762                1 => {
3763                    #[allow(irrefutable_let_patterns)]
3764                    if let ClientSelectorConfiguration::Selectors(_) = self {
3765                        // Do nothing, read the value into the object
3766                    } else {
3767                        // Initialize `self` to the right variant
3768                        *self = ClientSelectorConfiguration::Selectors(fidl::new_empty!(
3769                            fidl::encoding::UnboundedVector<SelectorArgument>,
3770                            D
3771                        ));
3772                    }
3773                    #[allow(irrefutable_let_patterns)]
3774                    if let ClientSelectorConfiguration::Selectors(ref mut val) = self {
3775                        fidl::decode!(
3776                            fidl::encoding::UnboundedVector<SelectorArgument>,
3777                            D,
3778                            val,
3779                            decoder,
3780                            _inner_offset,
3781                            depth
3782                        )?;
3783                    } else {
3784                        unreachable!()
3785                    }
3786                }
3787                2 => {
3788                    #[allow(irrefutable_let_patterns)]
3789                    if let ClientSelectorConfiguration::SelectAll(_) = self {
3790                        // Do nothing, read the value into the object
3791                    } else {
3792                        // Initialize `self` to the right variant
3793                        *self = ClientSelectorConfiguration::SelectAll(fidl::new_empty!(bool, D));
3794                    }
3795                    #[allow(irrefutable_let_patterns)]
3796                    if let ClientSelectorConfiguration::SelectAll(ref mut val) = self {
3797                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
3798                    } else {
3799                        unreachable!()
3800                    }
3801                }
3802                #[allow(deprecated)]
3803                ordinal => {
3804                    for _ in 0..num_handles {
3805                        decoder.drop_next_handle()?;
3806                    }
3807                    *self =
3808                        ClientSelectorConfiguration::__SourceBreaking { unknown_ordinal: ordinal };
3809                }
3810            }
3811            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
3812                return Err(fidl::Error::InvalidNumBytesInEnvelope);
3813            }
3814            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3815                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3816            }
3817            Ok(())
3818        }
3819    }
3820
3821    impl fidl::encoding::ValueTypeMarker for SelectorArgument {
3822        type Borrowed<'a> = &'a Self;
3823        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3824            value
3825        }
3826    }
3827
3828    unsafe impl fidl::encoding::TypeMarker for SelectorArgument {
3829        type Owned = Self;
3830
3831        #[inline(always)]
3832        fn inline_align(_context: fidl::encoding::Context) -> usize {
3833            8
3834        }
3835
3836        #[inline(always)]
3837        fn inline_size(_context: fidl::encoding::Context) -> usize {
3838            16
3839        }
3840    }
3841
3842    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SelectorArgument, D>
3843        for &SelectorArgument
3844    {
3845        #[inline]
3846        unsafe fn encode(
3847            self,
3848            encoder: &mut fidl::encoding::Encoder<'_, D>,
3849            offset: usize,
3850            _depth: fidl::encoding::Depth,
3851        ) -> fidl::Result<()> {
3852            encoder.debug_check_bounds::<SelectorArgument>(offset);
3853            encoder.write_num::<u64>(self.ordinal(), offset);
3854            match self {
3855            SelectorArgument::StructuredSelector(ref val) => {
3856                fidl::encoding::encode_in_envelope::<Selector, D>(
3857                    <Selector as fidl::encoding::ValueTypeMarker>::borrow(val),
3858                    encoder, offset + 8, _depth
3859                )
3860            }
3861            SelectorArgument::RawSelector(ref val) => {
3862                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
3863                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
3864                    encoder, offset + 8, _depth
3865                )
3866            }
3867            SelectorArgument::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
3868        }
3869        }
3870    }
3871
3872    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SelectorArgument {
3873        #[inline(always)]
3874        fn new_empty() -> Self {
3875            Self::__SourceBreaking { unknown_ordinal: 0 }
3876        }
3877
3878        #[inline]
3879        unsafe fn decode(
3880            &mut self,
3881            decoder: &mut fidl::encoding::Decoder<'_, D>,
3882            offset: usize,
3883            mut depth: fidl::encoding::Depth,
3884        ) -> fidl::Result<()> {
3885            decoder.debug_check_bounds::<Self>(offset);
3886            #[allow(unused_variables)]
3887            let next_out_of_line = decoder.next_out_of_line();
3888            let handles_before = decoder.remaining_handles();
3889            let (ordinal, inlined, num_bytes, num_handles) =
3890                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
3891
3892            let member_inline_size = match ordinal {
3893                1 => <Selector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
3894                2 => {
3895                    <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
3896                        decoder.context,
3897                    )
3898                }
3899                0 => return Err(fidl::Error::UnknownUnionTag),
3900                _ => num_bytes as usize,
3901            };
3902
3903            if inlined != (member_inline_size <= 4) {
3904                return Err(fidl::Error::InvalidInlineBitInEnvelope);
3905            }
3906            let _inner_offset;
3907            if inlined {
3908                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
3909                _inner_offset = offset + 8;
3910            } else {
3911                depth.increment()?;
3912                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3913            }
3914            match ordinal {
3915                1 => {
3916                    #[allow(irrefutable_let_patterns)]
3917                    if let SelectorArgument::StructuredSelector(_) = self {
3918                        // Do nothing, read the value into the object
3919                    } else {
3920                        // Initialize `self` to the right variant
3921                        *self = SelectorArgument::StructuredSelector(fidl::new_empty!(Selector, D));
3922                    }
3923                    #[allow(irrefutable_let_patterns)]
3924                    if let SelectorArgument::StructuredSelector(ref mut val) = self {
3925                        fidl::decode!(Selector, D, val, decoder, _inner_offset, depth)?;
3926                    } else {
3927                        unreachable!()
3928                    }
3929                }
3930                2 => {
3931                    #[allow(irrefutable_let_patterns)]
3932                    if let SelectorArgument::RawSelector(_) = self {
3933                        // Do nothing, read the value into the object
3934                    } else {
3935                        // Initialize `self` to the right variant
3936                        *self = SelectorArgument::RawSelector(fidl::new_empty!(
3937                            fidl::encoding::BoundedString<1024>,
3938                            D
3939                        ));
3940                    }
3941                    #[allow(irrefutable_let_patterns)]
3942                    if let SelectorArgument::RawSelector(ref mut val) = self {
3943                        fidl::decode!(
3944                            fidl::encoding::BoundedString<1024>,
3945                            D,
3946                            val,
3947                            decoder,
3948                            _inner_offset,
3949                            depth
3950                        )?;
3951                    } else {
3952                        unreachable!()
3953                    }
3954                }
3955                #[allow(deprecated)]
3956                ordinal => {
3957                    for _ in 0..num_handles {
3958                        decoder.drop_next_handle()?;
3959                    }
3960                    *self = SelectorArgument::__SourceBreaking { unknown_ordinal: ordinal };
3961                }
3962            }
3963            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
3964                return Err(fidl::Error::InvalidNumBytesInEnvelope);
3965            }
3966            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3967                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3968            }
3969            Ok(())
3970        }
3971    }
3972
3973    impl fidl::encoding::ValueTypeMarker for StringSelector {
3974        type Borrowed<'a> = &'a Self;
3975        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3976            value
3977        }
3978    }
3979
3980    unsafe impl fidl::encoding::TypeMarker for StringSelector {
3981        type Owned = Self;
3982
3983        #[inline(always)]
3984        fn inline_align(_context: fidl::encoding::Context) -> usize {
3985            8
3986        }
3987
3988        #[inline(always)]
3989        fn inline_size(_context: fidl::encoding::Context) -> usize {
3990            16
3991        }
3992    }
3993
3994    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StringSelector, D>
3995        for &StringSelector
3996    {
3997        #[inline]
3998        unsafe fn encode(
3999            self,
4000            encoder: &mut fidl::encoding::Encoder<'_, D>,
4001            offset: usize,
4002            _depth: fidl::encoding::Depth,
4003        ) -> fidl::Result<()> {
4004            encoder.debug_check_bounds::<StringSelector>(offset);
4005            encoder.write_num::<u64>(self.ordinal(), offset);
4006            match self {
4007            StringSelector::StringPattern(ref val) => {
4008                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
4009                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
4010                    encoder, offset + 8, _depth
4011                )
4012            }
4013            StringSelector::ExactMatch(ref val) => {
4014                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<1024>, D>(
4015                    <fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(val),
4016                    encoder, offset + 8, _depth
4017                )
4018            }
4019            StringSelector::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4020        }
4021        }
4022    }
4023
4024    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StringSelector {
4025        #[inline(always)]
4026        fn new_empty() -> Self {
4027            Self::__SourceBreaking { unknown_ordinal: 0 }
4028        }
4029
4030        #[inline]
4031        unsafe fn decode(
4032            &mut self,
4033            decoder: &mut fidl::encoding::Decoder<'_, D>,
4034            offset: usize,
4035            mut depth: fidl::encoding::Depth,
4036        ) -> fidl::Result<()> {
4037            decoder.debug_check_bounds::<Self>(offset);
4038            #[allow(unused_variables)]
4039            let next_out_of_line = decoder.next_out_of_line();
4040            let handles_before = decoder.remaining_handles();
4041            let (ordinal, inlined, num_bytes, num_handles) =
4042                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4043
4044            let member_inline_size = match ordinal {
4045                1 => {
4046                    <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
4047                        decoder.context,
4048                    )
4049                }
4050                2 => {
4051                    <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(
4052                        decoder.context,
4053                    )
4054                }
4055                0 => return Err(fidl::Error::UnknownUnionTag),
4056                _ => num_bytes as usize,
4057            };
4058
4059            if inlined != (member_inline_size <= 4) {
4060                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4061            }
4062            let _inner_offset;
4063            if inlined {
4064                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4065                _inner_offset = offset + 8;
4066            } else {
4067                depth.increment()?;
4068                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4069            }
4070            match ordinal {
4071                1 => {
4072                    #[allow(irrefutable_let_patterns)]
4073                    if let StringSelector::StringPattern(_) = self {
4074                        // Do nothing, read the value into the object
4075                    } else {
4076                        // Initialize `self` to the right variant
4077                        *self = StringSelector::StringPattern(fidl::new_empty!(
4078                            fidl::encoding::BoundedString<1024>,
4079                            D
4080                        ));
4081                    }
4082                    #[allow(irrefutable_let_patterns)]
4083                    if let StringSelector::StringPattern(ref mut val) = self {
4084                        fidl::decode!(
4085                            fidl::encoding::BoundedString<1024>,
4086                            D,
4087                            val,
4088                            decoder,
4089                            _inner_offset,
4090                            depth
4091                        )?;
4092                    } else {
4093                        unreachable!()
4094                    }
4095                }
4096                2 => {
4097                    #[allow(irrefutable_let_patterns)]
4098                    if let StringSelector::ExactMatch(_) = self {
4099                        // Do nothing, read the value into the object
4100                    } else {
4101                        // Initialize `self` to the right variant
4102                        *self = StringSelector::ExactMatch(fidl::new_empty!(
4103                            fidl::encoding::BoundedString<1024>,
4104                            D
4105                        ));
4106                    }
4107                    #[allow(irrefutable_let_patterns)]
4108                    if let StringSelector::ExactMatch(ref mut val) = self {
4109                        fidl::decode!(
4110                            fidl::encoding::BoundedString<1024>,
4111                            D,
4112                            val,
4113                            decoder,
4114                            _inner_offset,
4115                            depth
4116                        )?;
4117                    } else {
4118                        unreachable!()
4119                    }
4120                }
4121                #[allow(deprecated)]
4122                ordinal => {
4123                    for _ in 0..num_handles {
4124                        decoder.drop_next_handle()?;
4125                    }
4126                    *self = StringSelector::__SourceBreaking { unknown_ordinal: ordinal };
4127                }
4128            }
4129            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4130                return Err(fidl::Error::InvalidNumBytesInEnvelope);
4131            }
4132            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4133                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4134            }
4135            Ok(())
4136        }
4137    }
4138
4139    impl fidl::encoding::ValueTypeMarker for TreeNames {
4140        type Borrowed<'a> = &'a Self;
4141        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4142            value
4143        }
4144    }
4145
4146    unsafe impl fidl::encoding::TypeMarker for TreeNames {
4147        type Owned = Self;
4148
4149        #[inline(always)]
4150        fn inline_align(_context: fidl::encoding::Context) -> usize {
4151            8
4152        }
4153
4154        #[inline(always)]
4155        fn inline_size(_context: fidl::encoding::Context) -> usize {
4156            16
4157        }
4158    }
4159
4160    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TreeNames, D>
4161        for &TreeNames
4162    {
4163        #[inline]
4164        unsafe fn encode(
4165            self,
4166            encoder: &mut fidl::encoding::Encoder<'_, D>,
4167            offset: usize,
4168            _depth: fidl::encoding::Depth,
4169        ) -> fidl::Result<()> {
4170            encoder.debug_check_bounds::<TreeNames>(offset);
4171            encoder.write_num::<u64>(self.ordinal(), offset);
4172            match self {
4173            TreeNames::Some(ref val) => {
4174                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>, D>(
4175                    <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>> as fidl::encoding::ValueTypeMarker>::borrow(val),
4176                    encoder, offset + 8, _depth
4177                )
4178            }
4179            TreeNames::All(ref val) => {
4180                fidl::encoding::encode_in_envelope::<All, D>(
4181                    <All as fidl::encoding::ValueTypeMarker>::borrow(val),
4182                    encoder, offset + 8, _depth
4183                )
4184            }
4185            TreeNames::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4186        }
4187        }
4188    }
4189
4190    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TreeNames {
4191        #[inline(always)]
4192        fn new_empty() -> Self {
4193            Self::__SourceBreaking { unknown_ordinal: 0 }
4194        }
4195
4196        #[inline]
4197        unsafe fn decode(
4198            &mut self,
4199            decoder: &mut fidl::encoding::Decoder<'_, D>,
4200            offset: usize,
4201            mut depth: fidl::encoding::Depth,
4202        ) -> fidl::Result<()> {
4203            decoder.debug_check_bounds::<Self>(offset);
4204            #[allow(unused_variables)]
4205            let next_out_of_line = decoder.next_out_of_line();
4206            let handles_before = decoder.remaining_handles();
4207            let (ordinal, inlined, num_bytes, num_handles) =
4208                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4209
4210            let member_inline_size = match ordinal {
4211            1 => <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4212            2 => <All as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4213            0 => return Err(fidl::Error::UnknownUnionTag),
4214            _ => num_bytes as usize,
4215        };
4216
4217            if inlined != (member_inline_size <= 4) {
4218                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4219            }
4220            let _inner_offset;
4221            if inlined {
4222                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4223                _inner_offset = offset + 8;
4224            } else {
4225                depth.increment()?;
4226                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4227            }
4228            match ordinal {
4229                1 => {
4230                    #[allow(irrefutable_let_patterns)]
4231                    if let TreeNames::Some(_) = self {
4232                        // Do nothing, read the value into the object
4233                    } else {
4234                        // Initialize `self` to the right variant
4235                        *self = TreeNames::Some(fidl::new_empty!(
4236                            fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>,
4237                            D
4238                        ));
4239                    }
4240                    #[allow(irrefutable_let_patterns)]
4241                    if let TreeNames::Some(ref mut val) = self {
4242                        fidl::decode!(
4243                            fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<1024>>,
4244                            D,
4245                            val,
4246                            decoder,
4247                            _inner_offset,
4248                            depth
4249                        )?;
4250                    } else {
4251                        unreachable!()
4252                    }
4253                }
4254                2 => {
4255                    #[allow(irrefutable_let_patterns)]
4256                    if let TreeNames::All(_) = self {
4257                        // Do nothing, read the value into the object
4258                    } else {
4259                        // Initialize `self` to the right variant
4260                        *self = TreeNames::All(fidl::new_empty!(All, D));
4261                    }
4262                    #[allow(irrefutable_let_patterns)]
4263                    if let TreeNames::All(ref mut val) = self {
4264                        fidl::decode!(All, D, val, decoder, _inner_offset, depth)?;
4265                    } else {
4266                        unreachable!()
4267                    }
4268                }
4269                #[allow(deprecated)]
4270                ordinal => {
4271                    for _ in 0..num_handles {
4272                        decoder.drop_next_handle()?;
4273                    }
4274                    *self = TreeNames::__SourceBreaking { unknown_ordinal: ordinal };
4275                }
4276            }
4277            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4278                return Err(fidl::Error::InvalidNumBytesInEnvelope);
4279            }
4280            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4281                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4282            }
4283            Ok(())
4284        }
4285    }
4286
4287    impl fidl::encoding::ValueTypeMarker for TreeSelector {
4288        type Borrowed<'a> = &'a Self;
4289        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4290            value
4291        }
4292    }
4293
4294    unsafe impl fidl::encoding::TypeMarker for TreeSelector {
4295        type Owned = Self;
4296
4297        #[inline(always)]
4298        fn inline_align(_context: fidl::encoding::Context) -> usize {
4299            8
4300        }
4301
4302        #[inline(always)]
4303        fn inline_size(_context: fidl::encoding::Context) -> usize {
4304            16
4305        }
4306    }
4307
4308    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TreeSelector, D>
4309        for &TreeSelector
4310    {
4311        #[inline]
4312        unsafe fn encode(
4313            self,
4314            encoder: &mut fidl::encoding::Encoder<'_, D>,
4315            offset: usize,
4316            _depth: fidl::encoding::Depth,
4317        ) -> fidl::Result<()> {
4318            encoder.debug_check_bounds::<TreeSelector>(offset);
4319            encoder.write_num::<u64>(self.ordinal(), offset);
4320            match self {
4321                TreeSelector::SubtreeSelector(ref val) => {
4322                    fidl::encoding::encode_in_envelope::<SubtreeSelector, D>(
4323                        <SubtreeSelector as fidl::encoding::ValueTypeMarker>::borrow(val),
4324                        encoder,
4325                        offset + 8,
4326                        _depth,
4327                    )
4328                }
4329                TreeSelector::PropertySelector(ref val) => {
4330                    fidl::encoding::encode_in_envelope::<PropertySelector, D>(
4331                        <PropertySelector as fidl::encoding::ValueTypeMarker>::borrow(val),
4332                        encoder,
4333                        offset + 8,
4334                        _depth,
4335                    )
4336                }
4337                TreeSelector::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4338            }
4339        }
4340    }
4341
4342    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TreeSelector {
4343        #[inline(always)]
4344        fn new_empty() -> Self {
4345            Self::__SourceBreaking { unknown_ordinal: 0 }
4346        }
4347
4348        #[inline]
4349        unsafe fn decode(
4350            &mut self,
4351            decoder: &mut fidl::encoding::Decoder<'_, D>,
4352            offset: usize,
4353            mut depth: fidl::encoding::Depth,
4354        ) -> fidl::Result<()> {
4355            decoder.debug_check_bounds::<Self>(offset);
4356            #[allow(unused_variables)]
4357            let next_out_of_line = decoder.next_out_of_line();
4358            let handles_before = decoder.remaining_handles();
4359            let (ordinal, inlined, num_bytes, num_handles) =
4360                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4361
4362            let member_inline_size = match ordinal {
4363                1 => <SubtreeSelector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4364                2 => <PropertySelector as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4365                0 => return Err(fidl::Error::UnknownUnionTag),
4366                _ => num_bytes as usize,
4367            };
4368
4369            if inlined != (member_inline_size <= 4) {
4370                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4371            }
4372            let _inner_offset;
4373            if inlined {
4374                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4375                _inner_offset = offset + 8;
4376            } else {
4377                depth.increment()?;
4378                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4379            }
4380            match ordinal {
4381                1 => {
4382                    #[allow(irrefutable_let_patterns)]
4383                    if let TreeSelector::SubtreeSelector(_) = self {
4384                        // Do nothing, read the value into the object
4385                    } else {
4386                        // Initialize `self` to the right variant
4387                        *self = TreeSelector::SubtreeSelector(fidl::new_empty!(SubtreeSelector, D));
4388                    }
4389                    #[allow(irrefutable_let_patterns)]
4390                    if let TreeSelector::SubtreeSelector(ref mut val) = self {
4391                        fidl::decode!(SubtreeSelector, D, val, decoder, _inner_offset, depth)?;
4392                    } else {
4393                        unreachable!()
4394                    }
4395                }
4396                2 => {
4397                    #[allow(irrefutable_let_patterns)]
4398                    if let TreeSelector::PropertySelector(_) = self {
4399                        // Do nothing, read the value into the object
4400                    } else {
4401                        // Initialize `self` to the right variant
4402                        *self =
4403                            TreeSelector::PropertySelector(fidl::new_empty!(PropertySelector, D));
4404                    }
4405                    #[allow(irrefutable_let_patterns)]
4406                    if let TreeSelector::PropertySelector(ref mut val) = self {
4407                        fidl::decode!(PropertySelector, D, val, decoder, _inner_offset, depth)?;
4408                    } else {
4409                        unreachable!()
4410                    }
4411                }
4412                #[allow(deprecated)]
4413                ordinal => {
4414                    for _ in 0..num_handles {
4415                        decoder.drop_next_handle()?;
4416                    }
4417                    *self = TreeSelector::__SourceBreaking { unknown_ordinal: ordinal };
4418                }
4419            }
4420            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
4421                return Err(fidl::Error::InvalidNumBytesInEnvelope);
4422            }
4423            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4424                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4425            }
4426            Ok(())
4427        }
4428    }
4429}