fidl_fuchsia_net_mdns__common/
fidl_fuchsia_net_mdns__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Identifies a host. Host names consist of one or more labels separated by
12/// '.'s. A host name must not end with a '.'. Labels must each be 63 characters
13/// or less (not including the separator) and are UTF-8-encoded. A complete host
14/// name, including separators, must be 255 characters or less.
15pub type HostName = String;
16
17/// Identifies a specific instance of a service being published. Instance names
18/// consist of a single label, which is at most 63 characters long and which
19/// contains no '.'s. Instance names are UTF-8-encoded.
20pub type InstanceName = String;
21
22/// Identifies a (type of) service being published. Service names consist of
23/// two labels, both terminated with a '.'. The first label must start with an
24/// underscore and be 16 characters or less, including the underscore. The
25/// second label must be either '_tcp' or '_udp'. Labels do not contain '.'s.
26/// With underscores and terminators, that makes for a maximum of 22 characters.
27/// Service names are UTF-8-encoded.
28pub type ServiceName = String;
29
30/// Identifies a subtype of a service. Subtype names consist of a single label,
31/// which is at most 63 characters long and which contains no '.'s. Subtype
32/// names are UTF-8-encoded.
33pub type SubtypeName = String;
34
35/// Provides description relating to a service instance. In typical use, TXT
36/// strings consist of a key and value separated by '='. TXT strings must be
37/// at most 255 characters long and are UTF-8-encoded.
38pub type TxtCharacterString = Vec<u8>;
39
40/// Provides description relating to a service instance. In typical use, TXT
41/// strings consist of a key and value separated by '='. TXT strings must be
42/// at most 255 characters long and are UTF-8-encoded.
43pub type TxtString = String;
44
45pub const DEFAULT_PTR_TTL: i64 = 120000000000;
46
47pub const DEFAULT_SRV_PRIORITY: u16 = 0;
48
49pub const DEFAULT_SRV_TTL: i64 = 120000000000;
50
51pub const DEFAULT_SRV_WEIGHT: u16 = 0;
52
53pub const DEFAULT_TXT_TTL: i64 = 4500000000000;
54
55pub const MAX_ADDRESSES: u32 = 64;
56
57pub const MAX_SUBTYPES: u32 = 256;
58
59pub const MAX_TEXT_STRINGS: u32 = 256;
60
61bitflags! {
62    /// Specifies IP versions on which a service instance should be published.
63    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
64    pub struct IpVersions: u32 {
65        /// Specifies IPv4.
66        const V4 = 1;
67        /// Specifies IPv6.
68        const V6 = 2;
69    }
70}
71
72impl IpVersions {}
73
74bitflags! {
75    /// Specifies network media on which a service instance should be published.
76    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
77    pub struct Media: u32 {
78        /// Specifies wired interfaces.
79        const WIRED = 1;
80        /// Specifies wireless interfaces.
81        const WIRELESS = 2;
82    }
83}
84
85impl Media {}
86
87/// Error values for instance publishing.
88#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
89#[repr(u32)]
90pub enum Error {
91    /// The specified service name is invalid.
92    InvalidServiceName = 1,
93    /// The specified instance name is invalid.
94    InvalidInstanceName = 2,
95    /// The specified service instance is already being published by another
96    /// host on the subnet. This result occurs when an initial probe discovers
97    /// a conflicting instance.
98    AlreadyPublishedOnSubnet = 4,
99    InvalidMedia = 5,
100}
101
102impl Error {
103    #[inline]
104    pub fn from_primitive(prim: u32) -> Option<Self> {
105        match prim {
106            1 => Some(Self::InvalidServiceName),
107            2 => Some(Self::InvalidInstanceName),
108            4 => Some(Self::AlreadyPublishedOnSubnet),
109            5 => Some(Self::InvalidMedia),
110            _ => None,
111        }
112    }
113
114    #[inline]
115    pub const fn into_primitive(self) -> u32 {
116        self as u32
117    }
118}
119
120/// Error values for `ServiceInstancePublicationResponder.OnPublication`.
121#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
122#[repr(u32)]
123pub enum OnPublicationError {
124    /// Indicates the publisher should not respond to this publication request.
125    DoNotRespond = 1,
126}
127
128impl OnPublicationError {
129    #[inline]
130    pub fn from_primitive(prim: u32) -> Option<Self> {
131        match prim {
132            1 => Some(Self::DoNotRespond),
133            _ => None,
134        }
135    }
136
137    #[inline]
138    pub const fn into_primitive(self) -> u32 {
139        self as u32
140    }
141}
142
143/// Describes the cause of a publication.
144#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
145#[repr(u32)]
146pub enum PublicationCause {
147    /// Indicates the publication is part of an initial announcement.
148    Announcement = 1,
149    /// Indicates the publication is in response to a question that requests a
150    /// multicast response.
151    QueryMulticastResponse = 2,
152    /// Indicates the publication is in response to a question that requests a
153    /// unicast response.
154    QueryUnicastResponse = 3,
155}
156
157impl PublicationCause {
158    #[inline]
159    pub fn from_primitive(prim: u32) -> Option<Self> {
160        match prim {
161            1 => Some(Self::Announcement),
162            2 => Some(Self::QueryMulticastResponse),
163            3 => Some(Self::QueryUnicastResponse),
164            _ => None,
165        }
166    }
167
168    #[inline]
169    pub const fn into_primitive(self) -> u32 {
170        self as u32
171    }
172}
173
174/// Error values for `ProxyHostPublisher.PublishProxyHost`.
175#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
176pub enum PublishProxyHostError {
177    /// The specified host name is already being published by the mDNS local implementation.
178    AlreadyPublishedLocally,
179    /// The specified host name is already being published by another host on the subnet.
180    /// This result occurs when an initial probe discovers a conflicting host name.
181    AlreadyPublishedOnSubnet,
182    #[doc(hidden)]
183    __SourceBreaking { unknown_ordinal: u32 },
184}
185
186/// Pattern that matches an unknown `PublishProxyHostError` member.
187#[macro_export]
188macro_rules! PublishProxyHostErrorUnknown {
189    () => {
190        _
191    };
192}
193
194impl PublishProxyHostError {
195    #[inline]
196    pub fn from_primitive(prim: u32) -> Option<Self> {
197        match prim {
198            1 => Some(Self::AlreadyPublishedLocally),
199            2 => Some(Self::AlreadyPublishedOnSubnet),
200            _ => None,
201        }
202    }
203
204    #[inline]
205    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
206        match prim {
207            1 => Self::AlreadyPublishedLocally,
208            2 => Self::AlreadyPublishedOnSubnet,
209            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
210        }
211    }
212
213    #[inline]
214    pub fn unknown() -> Self {
215        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
216    }
217
218    #[inline]
219    pub const fn into_primitive(self) -> u32 {
220        match self {
221            Self::AlreadyPublishedLocally => 1,
222            Self::AlreadyPublishedOnSubnet => 2,
223            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
224        }
225    }
226
227    #[inline]
228    pub fn is_unknown(&self) -> bool {
229        match self {
230            Self::__SourceBreaking { unknown_ordinal: _ } => true,
231            _ => false,
232        }
233    }
234}
235
236/// Error values for `ServiceInstancePublisher.PublishServiceInstance`.
237#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
238#[repr(u32)]
239pub enum PublishServiceInstanceError {
240    /// The specified service instance is already being published by the mDNS local implementation.
241    AlreadyPublishedLocally = 1,
242    /// The specified service instance is already being published by another host on the subnet.
243    /// This result occurs when an initial probe discovers a conflicting service instance.
244    AlreadyPublishedOnSubnet = 2,
245}
246
247impl PublishServiceInstanceError {
248    #[inline]
249    pub fn from_primitive(prim: u32) -> Option<Self> {
250        match prim {
251            1 => Some(Self::AlreadyPublishedLocally),
252            2 => Some(Self::AlreadyPublishedOnSubnet),
253            _ => None,
254        }
255    }
256
257    #[inline]
258    pub const fn into_primitive(self) -> u32 {
259        self as u32
260    }
261}
262
263/// DNS resource types.
264#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
265#[repr(u32)]
266pub enum ResourceType {
267    /// Domain name pointer.
268    Ptr = 12,
269    /// Any (wildcard) type.
270    Any = 255,
271}
272
273impl ResourceType {
274    #[inline]
275    pub fn from_primitive(prim: u32) -> Option<Self> {
276        match prim {
277            12 => Some(Self::Ptr),
278            255 => Some(Self::Any),
279            _ => None,
280        }
281    }
282
283    #[inline]
284    pub const fn into_primitive(self) -> u32 {
285        self as u32
286    }
287}
288
289/// Describes the cause of a publication.
290#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
291#[repr(u32)]
292pub enum ServiceInstancePublicationCause {
293    /// Indicates the publication is part of an initial announcement.
294    Announcement = 1,
295    /// Indicates the publication is in response to a question that requests a
296    /// multicast response.
297    QueryMulticastResponse = 2,
298    /// Indicates the publication is in response to a question that requests a
299    /// unicast response.
300    QueryUnicastResponse = 3,
301}
302
303impl ServiceInstancePublicationCause {
304    #[inline]
305    pub fn from_primitive(prim: u32) -> Option<Self> {
306        match prim {
307            1 => Some(Self::Announcement),
308            2 => Some(Self::QueryMulticastResponse),
309            3 => Some(Self::QueryUnicastResponse),
310            _ => None,
311        }
312    }
313
314    #[inline]
315    pub const fn into_primitive(self) -> u32 {
316        self as u32
317    }
318}
319
320/// An IPv4 or IPv6 host address with the id of the interface through which the address was
321/// received.
322#[derive(Clone, Debug, PartialEq)]
323pub struct HostAddress {
324    /// IPv4 or IPv6 host address. In the case of the local host, this will be the address of the
325    /// interface idenfied by `interface`. In the case of local proxy hosts, this value will be a
326    /// non-link-local address.
327    pub address: fidl_fuchsia_net__common::IpAddress,
328    /// Interface through which the address was received. In the case of the local host, this will
329    /// be the interface id of the interface whose address is given by `address`. In the case of
330    /// local proxy hosts, this value will be zero.
331    pub interface: u64,
332    /// Time-to-live of the relevant A or AAAA resource. In the case of the local host or local
333    /// proxy hosts, this value will be 2 minutes, the default A/AAAA TTL.
334    pub ttl: i64,
335}
336
337impl fidl::Persistable for HostAddress {}
338
339#[derive(Clone, Debug, PartialEq)]
340pub struct HostNameResolverResolveHostNameRequest {
341    pub host: String,
342    pub timeout: i64,
343    pub options: HostNameResolutionOptions,
344}
345
346impl fidl::Persistable for HostNameResolverResolveHostNameRequest {}
347
348#[derive(Clone, Debug, PartialEq)]
349pub struct HostNameResolverResolveHostNameResponse {
350    pub addresses: Vec<HostAddress>,
351}
352
353impl fidl::Persistable for HostNameResolverResolveHostNameResponse {}
354
355#[derive(Clone, Debug, PartialEq)]
356pub struct HostNameSubscriptionListenerOnAddressesChangedRequest {
357    pub addresses: Vec<HostAddress>,
358}
359
360impl fidl::Persistable for HostNameSubscriptionListenerOnAddressesChangedRequest {}
361
362/// Describes an initial instance announcement or query response. In typical
363/// use, the default SRV priority, SRV weight and TTL values should be used. TTL
364/// values are rounded down to the nearest second. TTL values less than one
365/// second are not permitted and will result in the `PublicationResponder`
366/// channel being closed.
367#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
368pub struct Publication {
369    /// The port at which the service instance is addressable.
370    pub port: u16,
371    /// Text strings describing the instance.
372    pub text: Vec<String>,
373    /// The priority of the SRV resource record for this publication. See
374    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details.
375    pub srv_priority: u16,
376    /// The weight of the SRV resource record for this publication. See
377    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details.
378    pub srv_weight: u16,
379    /// Time-to-live for PTR resource records.
380    pub ptr_ttl: i64,
381    /// Time-to-live for SRV resource records.
382    pub srv_ttl: i64,
383    /// Time-to-live for TXT resource records.
384    pub txt_ttl: i64,
385}
386
387impl fidl::Persistable for Publication {}
388
389#[derive(Clone, Debug, PartialEq)]
390pub struct PublicationResponderOnPublicationRequest {
391    pub publication_cause: PublicationCause,
392    pub subtype: Option<String>,
393    pub source_addresses: Vec<fidl_fuchsia_net__common::IpAddress>,
394}
395
396impl fidl::Persistable for PublicationResponderOnPublicationRequest {}
397
398#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
399pub struct PublicationResponderOnPublicationResponse {
400    pub publication: Option<Box<Publication>>,
401}
402
403impl fidl::Persistable for PublicationResponderOnPublicationResponse {}
404
405#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
406pub struct PublicationResponderSetSubtypesRequest {
407    pub subtypes: Vec<String>,
408}
409
410impl fidl::Persistable for PublicationResponderSetSubtypesRequest {}
411
412#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
413pub struct ResolverResolveHostNameRequest {
414    pub host: String,
415    pub timeout: i64,
416}
417
418impl fidl::Persistable for ResolverResolveHostNameRequest {}
419
420#[derive(Clone, Debug, PartialEq)]
421pub struct ResolverResolveHostNameResponse {
422    pub v4_address: Option<Box<fidl_fuchsia_net__common::Ipv4Address>>,
423    pub v6_address: Option<Box<fidl_fuchsia_net__common::Ipv6Address>>,
424}
425
426impl fidl::Persistable for ResolverResolveHostNameResponse {}
427
428#[derive(Clone, Debug, PartialEq)]
429pub struct ServiceInstancePublicationResponderOnPublicationRequest {
430    pub publication_cause: ServiceInstancePublicationCause,
431    pub subtype: Option<String>,
432    pub source_addresses: Vec<fidl_fuchsia_net__common::IpAddress>,
433}
434
435impl fidl::Persistable for ServiceInstancePublicationResponderOnPublicationRequest {}
436
437#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
438pub struct ServiceInstancePublicationResponderSetSubtypesRequest {
439    pub subtypes: Vec<String>,
440}
441
442impl fidl::Persistable for ServiceInstancePublicationResponderSetSubtypesRequest {}
443
444#[derive(Clone, Debug, PartialEq)]
445pub struct ServiceInstancePublicationResponderOnPublicationResponse {
446    pub publication: ServiceInstancePublication,
447}
448
449impl fidl::Persistable for ServiceInstancePublicationResponderOnPublicationResponse {}
450
451#[derive(Clone, Debug, PartialEq)]
452pub struct ServiceInstanceResolverResolveServiceInstanceRequest {
453    pub service: String,
454    pub instance: String,
455    pub timeout: i64,
456    pub options: ServiceInstanceResolutionOptions,
457}
458
459impl fidl::Persistable for ServiceInstanceResolverResolveServiceInstanceRequest {}
460
461#[derive(Clone, Debug, PartialEq)]
462pub struct ServiceInstanceResolverResolveServiceInstanceResponse {
463    pub instance: ServiceInstance,
464}
465
466impl fidl::Persistable for ServiceInstanceResolverResolveServiceInstanceResponse {}
467
468#[derive(Clone, Debug, PartialEq)]
469pub struct ServiceSubscriberOnInstanceChangedRequest {
470    pub instance: ServiceInstance,
471}
472
473impl fidl::Persistable for ServiceSubscriberOnInstanceChangedRequest {}
474
475#[derive(Clone, Debug, PartialEq)]
476pub struct ServiceSubscriberOnInstanceDiscoveredRequest {
477    pub instance: ServiceInstance,
478}
479
480impl fidl::Persistable for ServiceSubscriberOnInstanceDiscoveredRequest {}
481
482#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
483pub struct ServiceSubscriberOnInstanceLostRequest {
484    pub service: String,
485    pub instance: String,
486}
487
488impl fidl::Persistable for ServiceSubscriberOnInstanceLostRequest {}
489
490#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
491pub struct ServiceSubscriberOnQueryRequest {
492    pub resource_type: ResourceType,
493}
494
495impl fidl::Persistable for ServiceSubscriberOnQueryRequest {}
496
497#[derive(Clone, Debug, PartialEq)]
498pub struct ServiceSubscriptionListenerOnInstanceChangedRequest {
499    pub instance: ServiceInstance,
500}
501
502impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceChangedRequest {}
503
504#[derive(Clone, Debug, PartialEq)]
505pub struct ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
506    pub instance: ServiceInstance,
507}
508
509impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {}
510
511#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
512pub struct ServiceSubscriptionListenerOnInstanceLostRequest {
513    pub service: String,
514    pub instance: String,
515}
516
517impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceLostRequest {}
518
519#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
520pub struct ServiceSubscriptionListenerOnQueryRequest {
521    pub resource_type: ResourceType,
522}
523
524impl fidl::Persistable for ServiceSubscriptionListenerOnQueryRequest {}
525
526/// Options for `HostNameResolver.ResolveHostName`.
527#[derive(Clone, Debug, Default, PartialEq)]
528pub struct HostNameResolutionOptions {
529    /// The media (wired, wireless, both) of the interfaces on which the host name should be
530    /// resolved. The default is both wired and wireless media.
531    pub media: Option<Media>,
532    /// The IP versions (V4, V6, both) with which the host name should resolved. The default
533    /// value is both IPv4 and IPv6.
534    pub ip_versions: Option<IpVersions>,
535    pub exclude_local: Option<bool>,
536    pub exclude_local_proxies: Option<bool>,
537    #[doc(hidden)]
538    pub __source_breaking: fidl::marker::SourceBreaking,
539}
540
541impl fidl::Persistable for HostNameResolutionOptions {}
542
543/// Options for `HostNameSubscriber.SubscribeToHostName`.
544#[derive(Clone, Debug, Default, PartialEq)]
545pub struct HostNameSubscriptionOptions {
546    /// The media (wired, wireless, both) of the interfaces on which the host name should be
547    /// subscribed to. The default is both wired and wireless media.
548    pub media: Option<Media>,
549    /// The IP versions (V4, V6, both) with which the host name should subscribe to. The default
550    /// value is both IPv4 and IPv6.
551    pub ip_versions: Option<IpVersions>,
552    pub exclude_local: Option<bool>,
553    pub exclude_local_proxies: Option<bool>,
554    #[doc(hidden)]
555    pub __source_breaking: fidl::marker::SourceBreaking,
556}
557
558impl fidl::Persistable for HostNameSubscriptionOptions {}
559
560/// Options for `ProxyHostPublisher.PublishProxyHost`.
561#[derive(Clone, Debug, Default, PartialEq)]
562pub struct ProxyHostPublicationOptions {
563    /// The media (wired, wireless, both) of the interfaces on which the host name should be
564    /// published. If this value is not supplied, the host name will be published on wired and
565    /// wireless media.
566    pub media: Option<Media>,
567    /// The IP versions (V4, V6, both) of the interfaces on which the host name should be published.
568    /// If this value is not supplied, the host name will be published on interfaces of both IP
569    /// versions.
570    pub ip_versions: Option<IpVersions>,
571    /// Whether a probe for conflicting host names should be performed prior to publishing the
572    /// host name. If this value is not supplied, probing is performed.
573    pub perform_probe: Option<bool>,
574    #[doc(hidden)]
575    pub __source_breaking: fidl::marker::SourceBreaking,
576}
577
578impl fidl::Persistable for ProxyHostPublicationOptions {}
579
580/// Describes a service instance.
581#[derive(Clone, Debug, Default, PartialEq)]
582pub struct ServiceInstance {
583    /// The name of the service.
584    pub service: Option<String>,
585    /// The name of the service instance.
586    pub instance: Option<String>,
587    /// IPv4 socket address for the service. May be empty. Deprecated: use `addresses`.
588    pub ipv4_endpoint: Option<fidl_fuchsia_net__common::Ipv4SocketAddress>,
589    /// IPv6 socket address for the service. May be empty. Deprecated: use `addresses`.
590    pub ipv6_endpoint: Option<fidl_fuchsia_net__common::Ipv6SocketAddress>,
591    /// Text strings describing the instance. Deprecated: use `text_strings`.
592    pub text: Option<Vec<String>>,
593    /// The priority of the SRV resource record for this publication. See
594    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details.
595    pub srv_priority: Option<u16>,
596    /// The weight of the SRV resource record for this publication. See
597    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details.
598    pub srv_weight: Option<u16>,
599    /// The domain name of the target host.
600    pub target: Option<String>,
601    /// The socket addresses for the service instance.
602    pub addresses: Option<Vec<fidl_fuchsia_net__common::SocketAddress>>,
603    /// Text strings describing the instance.
604    pub text_strings: Option<Vec<Vec<u8>>>,
605    #[doc(hidden)]
606    pub __source_breaking: fidl::marker::SourceBreaking,
607}
608
609impl fidl::Persistable for ServiceInstance {}
610
611/// Describes an initial instance announcement or query response. In typical
612/// use, the default SRV priority, SRV weight and TTL values should be used. TTL
613/// values are rounded down to the nearest second. TTL values less than one
614/// second are not permitted and will result in the `ServiceInstancePublicationResponder`
615/// channel being closed.
616#[derive(Clone, Debug, Default, PartialEq)]
617pub struct ServiceInstancePublication {
618    /// The port at which the service instance is addressable. This value is required.
619    pub port: Option<u16>,
620    /// Text strings describing the instance. If this value is not supplied, no text strings are
621    /// associated with the instance in this publication.
622    pub text: Option<Vec<Vec<u8>>>,
623    /// The priority of the SRV resource record for this publication. See
624    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details. If this value is not supplied,
625    /// the default SRV priority of 0 is used.
626    pub srv_priority: Option<u16>,
627    /// The weight of the SRV resource record for this publication. See
628    /// [RFC6763](https://tools.ietf.org/html/rfc6763) for details. If this value is not supplied,
629    /// the default SRV weight of 0 is used.
630    pub srv_weight: Option<u16>,
631    /// Time-to-live for PTR resource records. If this value is not supplied, the default PTR TTL
632    /// of 2 minutes is used. This value is rounded down to the nearest second.
633    pub ptr_ttl: Option<i64>,
634    /// Time-to-live for SRV resource records. If this value is not supplied, the default SRV TTL
635    /// of 2 minutes is used. This value is rounded down to the nearest second.
636    pub srv_ttl: Option<i64>,
637    /// Time-to-live for TXT resource records. If this value is not supplied, the default TXT TTL
638    /// of 75 minutes is used. This value is rounded down to the nearest second.
639    pub txt_ttl: Option<i64>,
640    #[doc(hidden)]
641    pub __source_breaking: fidl::marker::SourceBreaking,
642}
643
644impl fidl::Persistable for ServiceInstancePublication {}
645
646/// Options for `ServiceInstancePublisher.PublishServiceInstance`.
647#[derive(Clone, Debug, Default, PartialEq)]
648pub struct ServiceInstancePublicationOptions {
649    /// The media (wired, wireless, both) of the interfaces on which the service instance should
650    /// be published. The default `media` value depends on whether the `ServiceInstancePublisher`
651    /// is associated with a proxy host. If so, the default matches the `media` value of the
652    /// `ProxyHostPublicationOptions` for the proxy host. If not, the default is both wired and
653    /// wireless media.
654    pub media: Option<Media>,
655    /// The IP versions (V4, V6, both) with which the service instance should
656    /// be published. The default `ip_versions` value depends on whether the
657    /// `ServiceInstancePublisher` is associated with a proxy host. If so, the default matches the
658    /// `ip_versions` value of the `ProxyHostPublicationOptions` for the proxy host. If not, the
659    /// default value is both IPv4 and IPv6.
660    pub ip_versions: Option<IpVersions>,
661    /// Whether a probe for conflicting instances should be performed prior to publishing the
662    /// instance. If this value is not supplied, probing is performed.
663    pub perform_probe: Option<bool>,
664    #[doc(hidden)]
665    pub __source_breaking: fidl::marker::SourceBreaking,
666}
667
668impl fidl::Persistable for ServiceInstancePublicationOptions {}
669
670/// Options for `ServiceInstanceResolver.ResolveServiceInstance`.
671#[derive(Clone, Debug, Default, PartialEq)]
672pub struct ServiceInstanceResolutionOptions {
673    /// The media (wired, wireless, both) of the interfaces on which the service instance should be
674    /// resolved. The default is both wired and wireless media.
675    pub media: Option<Media>,
676    /// The IP versions (V4, V6, both) with which the service instance should resolved. The default
677    /// value is both IPv4 and IPv6.
678    pub ip_versions: Option<IpVersions>,
679    pub exclude_local: Option<bool>,
680    pub exclude_local_proxies: Option<bool>,
681    #[doc(hidden)]
682    pub __source_breaking: fidl::marker::SourceBreaking,
683}
684
685impl fidl::Persistable for ServiceInstanceResolutionOptions {}
686
687/// Options for `ServiceSubscriber.SubscribeToService`.
688#[derive(Clone, Debug, Default, PartialEq)]
689pub struct ServiceSubscriptionOptions {
690    /// The media (wired, wireless, both) of the interfaces on which the service should be
691    /// susbsribed. The default is both wired and wireless media.
692    pub media: Option<Media>,
693    /// The IP versions (V4, V6, both) with which the service should subscribed. The default value
694    /// is both IPv4 and IPv6.
695    pub ip_versions: Option<IpVersions>,
696    pub exclude_local: Option<bool>,
697    pub exclude_local_proxies: Option<bool>,
698    #[doc(hidden)]
699    pub __source_breaking: fidl::marker::SourceBreaking,
700}
701
702impl fidl::Persistable for ServiceSubscriptionOptions {}
703
704mod internal {
705    use super::*;
706    unsafe impl fidl::encoding::TypeMarker for IpVersions {
707        type Owned = Self;
708
709        #[inline(always)]
710        fn inline_align(_context: fidl::encoding::Context) -> usize {
711            4
712        }
713
714        #[inline(always)]
715        fn inline_size(_context: fidl::encoding::Context) -> usize {
716            4
717        }
718    }
719
720    impl fidl::encoding::ValueTypeMarker for IpVersions {
721        type Borrowed<'a> = Self;
722        #[inline(always)]
723        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
724            *value
725        }
726    }
727
728    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IpVersions {
729        #[inline]
730        unsafe fn encode(
731            self,
732            encoder: &mut fidl::encoding::Encoder<'_, D>,
733            offset: usize,
734            _depth: fidl::encoding::Depth,
735        ) -> fidl::Result<()> {
736            encoder.debug_check_bounds::<Self>(offset);
737            if self.bits() & Self::all().bits() != self.bits() {
738                return Err(fidl::Error::InvalidBitsValue);
739            }
740            encoder.write_num(self.bits(), offset);
741            Ok(())
742        }
743    }
744
745    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpVersions {
746        #[inline(always)]
747        fn new_empty() -> Self {
748            Self::empty()
749        }
750
751        #[inline]
752        unsafe fn decode(
753            &mut self,
754            decoder: &mut fidl::encoding::Decoder<'_, D>,
755            offset: usize,
756            _depth: fidl::encoding::Depth,
757        ) -> fidl::Result<()> {
758            decoder.debug_check_bounds::<Self>(offset);
759            let prim = decoder.read_num::<u32>(offset);
760            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
761            Ok(())
762        }
763    }
764    unsafe impl fidl::encoding::TypeMarker for Media {
765        type Owned = Self;
766
767        #[inline(always)]
768        fn inline_align(_context: fidl::encoding::Context) -> usize {
769            4
770        }
771
772        #[inline(always)]
773        fn inline_size(_context: fidl::encoding::Context) -> usize {
774            4
775        }
776    }
777
778    impl fidl::encoding::ValueTypeMarker for Media {
779        type Borrowed<'a> = Self;
780        #[inline(always)]
781        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
782            *value
783        }
784    }
785
786    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Media {
787        #[inline]
788        unsafe fn encode(
789            self,
790            encoder: &mut fidl::encoding::Encoder<'_, D>,
791            offset: usize,
792            _depth: fidl::encoding::Depth,
793        ) -> fidl::Result<()> {
794            encoder.debug_check_bounds::<Self>(offset);
795            if self.bits() & Self::all().bits() != self.bits() {
796                return Err(fidl::Error::InvalidBitsValue);
797            }
798            encoder.write_num(self.bits(), offset);
799            Ok(())
800        }
801    }
802
803    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Media {
804        #[inline(always)]
805        fn new_empty() -> Self {
806            Self::empty()
807        }
808
809        #[inline]
810        unsafe fn decode(
811            &mut self,
812            decoder: &mut fidl::encoding::Decoder<'_, D>,
813            offset: usize,
814            _depth: fidl::encoding::Depth,
815        ) -> fidl::Result<()> {
816            decoder.debug_check_bounds::<Self>(offset);
817            let prim = decoder.read_num::<u32>(offset);
818            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
819            Ok(())
820        }
821    }
822    unsafe impl fidl::encoding::TypeMarker for Error {
823        type Owned = Self;
824
825        #[inline(always)]
826        fn inline_align(_context: fidl::encoding::Context) -> usize {
827            std::mem::align_of::<u32>()
828        }
829
830        #[inline(always)]
831        fn inline_size(_context: fidl::encoding::Context) -> usize {
832            std::mem::size_of::<u32>()
833        }
834
835        #[inline(always)]
836        fn encode_is_copy() -> bool {
837            true
838        }
839
840        #[inline(always)]
841        fn decode_is_copy() -> bool {
842            false
843        }
844    }
845
846    impl fidl::encoding::ValueTypeMarker for Error {
847        type Borrowed<'a> = Self;
848        #[inline(always)]
849        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
850            *value
851        }
852    }
853
854    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
855        #[inline]
856        unsafe fn encode(
857            self,
858            encoder: &mut fidl::encoding::Encoder<'_, D>,
859            offset: usize,
860            _depth: fidl::encoding::Depth,
861        ) -> fidl::Result<()> {
862            encoder.debug_check_bounds::<Self>(offset);
863            encoder.write_num(self.into_primitive(), offset);
864            Ok(())
865        }
866    }
867
868    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
869        #[inline(always)]
870        fn new_empty() -> Self {
871            Self::InvalidServiceName
872        }
873
874        #[inline]
875        unsafe fn decode(
876            &mut self,
877            decoder: &mut fidl::encoding::Decoder<'_, D>,
878            offset: usize,
879            _depth: fidl::encoding::Depth,
880        ) -> fidl::Result<()> {
881            decoder.debug_check_bounds::<Self>(offset);
882            let prim = decoder.read_num::<u32>(offset);
883
884            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
885            Ok(())
886        }
887    }
888    unsafe impl fidl::encoding::TypeMarker for OnPublicationError {
889        type Owned = Self;
890
891        #[inline(always)]
892        fn inline_align(_context: fidl::encoding::Context) -> usize {
893            std::mem::align_of::<u32>()
894        }
895
896        #[inline(always)]
897        fn inline_size(_context: fidl::encoding::Context) -> usize {
898            std::mem::size_of::<u32>()
899        }
900
901        #[inline(always)]
902        fn encode_is_copy() -> bool {
903            true
904        }
905
906        #[inline(always)]
907        fn decode_is_copy() -> bool {
908            false
909        }
910    }
911
912    impl fidl::encoding::ValueTypeMarker for OnPublicationError {
913        type Borrowed<'a> = Self;
914        #[inline(always)]
915        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
916            *value
917        }
918    }
919
920    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
921        for OnPublicationError
922    {
923        #[inline]
924        unsafe fn encode(
925            self,
926            encoder: &mut fidl::encoding::Encoder<'_, D>,
927            offset: usize,
928            _depth: fidl::encoding::Depth,
929        ) -> fidl::Result<()> {
930            encoder.debug_check_bounds::<Self>(offset);
931            encoder.write_num(self.into_primitive(), offset);
932            Ok(())
933        }
934    }
935
936    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnPublicationError {
937        #[inline(always)]
938        fn new_empty() -> Self {
939            Self::DoNotRespond
940        }
941
942        #[inline]
943        unsafe fn decode(
944            &mut self,
945            decoder: &mut fidl::encoding::Decoder<'_, D>,
946            offset: usize,
947            _depth: fidl::encoding::Depth,
948        ) -> fidl::Result<()> {
949            decoder.debug_check_bounds::<Self>(offset);
950            let prim = decoder.read_num::<u32>(offset);
951
952            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
953            Ok(())
954        }
955    }
956    unsafe impl fidl::encoding::TypeMarker for PublicationCause {
957        type Owned = Self;
958
959        #[inline(always)]
960        fn inline_align(_context: fidl::encoding::Context) -> usize {
961            std::mem::align_of::<u32>()
962        }
963
964        #[inline(always)]
965        fn inline_size(_context: fidl::encoding::Context) -> usize {
966            std::mem::size_of::<u32>()
967        }
968
969        #[inline(always)]
970        fn encode_is_copy() -> bool {
971            true
972        }
973
974        #[inline(always)]
975        fn decode_is_copy() -> bool {
976            false
977        }
978    }
979
980    impl fidl::encoding::ValueTypeMarker for PublicationCause {
981        type Borrowed<'a> = Self;
982        #[inline(always)]
983        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
984            *value
985        }
986    }
987
988    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
989        for PublicationCause
990    {
991        #[inline]
992        unsafe fn encode(
993            self,
994            encoder: &mut fidl::encoding::Encoder<'_, D>,
995            offset: usize,
996            _depth: fidl::encoding::Depth,
997        ) -> fidl::Result<()> {
998            encoder.debug_check_bounds::<Self>(offset);
999            encoder.write_num(self.into_primitive(), offset);
1000            Ok(())
1001        }
1002    }
1003
1004    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublicationCause {
1005        #[inline(always)]
1006        fn new_empty() -> Self {
1007            Self::Announcement
1008        }
1009
1010        #[inline]
1011        unsafe fn decode(
1012            &mut self,
1013            decoder: &mut fidl::encoding::Decoder<'_, D>,
1014            offset: usize,
1015            _depth: fidl::encoding::Depth,
1016        ) -> fidl::Result<()> {
1017            decoder.debug_check_bounds::<Self>(offset);
1018            let prim = decoder.read_num::<u32>(offset);
1019
1020            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1021            Ok(())
1022        }
1023    }
1024    unsafe impl fidl::encoding::TypeMarker for PublishProxyHostError {
1025        type Owned = Self;
1026
1027        #[inline(always)]
1028        fn inline_align(_context: fidl::encoding::Context) -> usize {
1029            std::mem::align_of::<u32>()
1030        }
1031
1032        #[inline(always)]
1033        fn inline_size(_context: fidl::encoding::Context) -> usize {
1034            std::mem::size_of::<u32>()
1035        }
1036
1037        #[inline(always)]
1038        fn encode_is_copy() -> bool {
1039            false
1040        }
1041
1042        #[inline(always)]
1043        fn decode_is_copy() -> bool {
1044            false
1045        }
1046    }
1047
1048    impl fidl::encoding::ValueTypeMarker for PublishProxyHostError {
1049        type Borrowed<'a> = Self;
1050        #[inline(always)]
1051        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1052            *value
1053        }
1054    }
1055
1056    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1057        for PublishProxyHostError
1058    {
1059        #[inline]
1060        unsafe fn encode(
1061            self,
1062            encoder: &mut fidl::encoding::Encoder<'_, D>,
1063            offset: usize,
1064            _depth: fidl::encoding::Depth,
1065        ) -> fidl::Result<()> {
1066            encoder.debug_check_bounds::<Self>(offset);
1067            encoder.write_num(self.into_primitive(), offset);
1068            Ok(())
1069        }
1070    }
1071
1072    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublishProxyHostError {
1073        #[inline(always)]
1074        fn new_empty() -> Self {
1075            Self::unknown()
1076        }
1077
1078        #[inline]
1079        unsafe fn decode(
1080            &mut self,
1081            decoder: &mut fidl::encoding::Decoder<'_, D>,
1082            offset: usize,
1083            _depth: fidl::encoding::Depth,
1084        ) -> fidl::Result<()> {
1085            decoder.debug_check_bounds::<Self>(offset);
1086            let prim = decoder.read_num::<u32>(offset);
1087
1088            *self = Self::from_primitive_allow_unknown(prim);
1089            Ok(())
1090        }
1091    }
1092    unsafe impl fidl::encoding::TypeMarker for PublishServiceInstanceError {
1093        type Owned = Self;
1094
1095        #[inline(always)]
1096        fn inline_align(_context: fidl::encoding::Context) -> usize {
1097            std::mem::align_of::<u32>()
1098        }
1099
1100        #[inline(always)]
1101        fn inline_size(_context: fidl::encoding::Context) -> usize {
1102            std::mem::size_of::<u32>()
1103        }
1104
1105        #[inline(always)]
1106        fn encode_is_copy() -> bool {
1107            true
1108        }
1109
1110        #[inline(always)]
1111        fn decode_is_copy() -> bool {
1112            false
1113        }
1114    }
1115
1116    impl fidl::encoding::ValueTypeMarker for PublishServiceInstanceError {
1117        type Borrowed<'a> = Self;
1118        #[inline(always)]
1119        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1120            *value
1121        }
1122    }
1123
1124    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1125        for PublishServiceInstanceError
1126    {
1127        #[inline]
1128        unsafe fn encode(
1129            self,
1130            encoder: &mut fidl::encoding::Encoder<'_, D>,
1131            offset: usize,
1132            _depth: fidl::encoding::Depth,
1133        ) -> fidl::Result<()> {
1134            encoder.debug_check_bounds::<Self>(offset);
1135            encoder.write_num(self.into_primitive(), offset);
1136            Ok(())
1137        }
1138    }
1139
1140    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1141        for PublishServiceInstanceError
1142    {
1143        #[inline(always)]
1144        fn new_empty() -> Self {
1145            Self::AlreadyPublishedLocally
1146        }
1147
1148        #[inline]
1149        unsafe fn decode(
1150            &mut self,
1151            decoder: &mut fidl::encoding::Decoder<'_, D>,
1152            offset: usize,
1153            _depth: fidl::encoding::Depth,
1154        ) -> fidl::Result<()> {
1155            decoder.debug_check_bounds::<Self>(offset);
1156            let prim = decoder.read_num::<u32>(offset);
1157
1158            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1159            Ok(())
1160        }
1161    }
1162    unsafe impl fidl::encoding::TypeMarker for ResourceType {
1163        type Owned = Self;
1164
1165        #[inline(always)]
1166        fn inline_align(_context: fidl::encoding::Context) -> usize {
1167            std::mem::align_of::<u32>()
1168        }
1169
1170        #[inline(always)]
1171        fn inline_size(_context: fidl::encoding::Context) -> usize {
1172            std::mem::size_of::<u32>()
1173        }
1174
1175        #[inline(always)]
1176        fn encode_is_copy() -> bool {
1177            true
1178        }
1179
1180        #[inline(always)]
1181        fn decode_is_copy() -> bool {
1182            false
1183        }
1184    }
1185
1186    impl fidl::encoding::ValueTypeMarker for ResourceType {
1187        type Borrowed<'a> = Self;
1188        #[inline(always)]
1189        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1190            *value
1191        }
1192    }
1193
1194    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResourceType {
1195        #[inline]
1196        unsafe fn encode(
1197            self,
1198            encoder: &mut fidl::encoding::Encoder<'_, D>,
1199            offset: usize,
1200            _depth: fidl::encoding::Depth,
1201        ) -> fidl::Result<()> {
1202            encoder.debug_check_bounds::<Self>(offset);
1203            encoder.write_num(self.into_primitive(), offset);
1204            Ok(())
1205        }
1206    }
1207
1208    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResourceType {
1209        #[inline(always)]
1210        fn new_empty() -> Self {
1211            Self::Ptr
1212        }
1213
1214        #[inline]
1215        unsafe fn decode(
1216            &mut self,
1217            decoder: &mut fidl::encoding::Decoder<'_, D>,
1218            offset: usize,
1219            _depth: fidl::encoding::Depth,
1220        ) -> fidl::Result<()> {
1221            decoder.debug_check_bounds::<Self>(offset);
1222            let prim = decoder.read_num::<u32>(offset);
1223
1224            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1225            Ok(())
1226        }
1227    }
1228    unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationCause {
1229        type Owned = Self;
1230
1231        #[inline(always)]
1232        fn inline_align(_context: fidl::encoding::Context) -> usize {
1233            std::mem::align_of::<u32>()
1234        }
1235
1236        #[inline(always)]
1237        fn inline_size(_context: fidl::encoding::Context) -> usize {
1238            std::mem::size_of::<u32>()
1239        }
1240
1241        #[inline(always)]
1242        fn encode_is_copy() -> bool {
1243            true
1244        }
1245
1246        #[inline(always)]
1247        fn decode_is_copy() -> bool {
1248            false
1249        }
1250    }
1251
1252    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationCause {
1253        type Borrowed<'a> = Self;
1254        #[inline(always)]
1255        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1256            *value
1257        }
1258    }
1259
1260    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1261        for ServiceInstancePublicationCause
1262    {
1263        #[inline]
1264        unsafe fn encode(
1265            self,
1266            encoder: &mut fidl::encoding::Encoder<'_, D>,
1267            offset: usize,
1268            _depth: fidl::encoding::Depth,
1269        ) -> fidl::Result<()> {
1270            encoder.debug_check_bounds::<Self>(offset);
1271            encoder.write_num(self.into_primitive(), offset);
1272            Ok(())
1273        }
1274    }
1275
1276    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1277        for ServiceInstancePublicationCause
1278    {
1279        #[inline(always)]
1280        fn new_empty() -> Self {
1281            Self::Announcement
1282        }
1283
1284        #[inline]
1285        unsafe fn decode(
1286            &mut self,
1287            decoder: &mut fidl::encoding::Decoder<'_, D>,
1288            offset: usize,
1289            _depth: fidl::encoding::Depth,
1290        ) -> fidl::Result<()> {
1291            decoder.debug_check_bounds::<Self>(offset);
1292            let prim = decoder.read_num::<u32>(offset);
1293
1294            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1295            Ok(())
1296        }
1297    }
1298
1299    impl fidl::encoding::ValueTypeMarker for HostAddress {
1300        type Borrowed<'a> = &'a Self;
1301        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1302            value
1303        }
1304    }
1305
1306    unsafe impl fidl::encoding::TypeMarker for HostAddress {
1307        type Owned = Self;
1308
1309        #[inline(always)]
1310        fn inline_align(_context: fidl::encoding::Context) -> usize {
1311            8
1312        }
1313
1314        #[inline(always)]
1315        fn inline_size(_context: fidl::encoding::Context) -> usize {
1316            32
1317        }
1318    }
1319
1320    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HostAddress, D>
1321        for &HostAddress
1322    {
1323        #[inline]
1324        unsafe fn encode(
1325            self,
1326            encoder: &mut fidl::encoding::Encoder<'_, D>,
1327            offset: usize,
1328            _depth: fidl::encoding::Depth,
1329        ) -> fidl::Result<()> {
1330            encoder.debug_check_bounds::<HostAddress>(offset);
1331            // Delegate to tuple encoding.
1332            fidl::encoding::Encode::<HostAddress, D>::encode(
1333                (
1334                    <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1335                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface),
1336                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ttl),
1337                ),
1338                encoder, offset, _depth
1339            )
1340        }
1341    }
1342    unsafe impl<
1343            D: fidl::encoding::ResourceDialect,
1344            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
1345            T1: fidl::encoding::Encode<u64, D>,
1346            T2: fidl::encoding::Encode<i64, D>,
1347        > fidl::encoding::Encode<HostAddress, D> for (T0, T1, T2)
1348    {
1349        #[inline]
1350        unsafe fn encode(
1351            self,
1352            encoder: &mut fidl::encoding::Encoder<'_, D>,
1353            offset: usize,
1354            depth: fidl::encoding::Depth,
1355        ) -> fidl::Result<()> {
1356            encoder.debug_check_bounds::<HostAddress>(offset);
1357            // Zero out padding regions. There's no need to apply masks
1358            // because the unmasked parts will be overwritten by fields.
1359            // Write the fields.
1360            self.0.encode(encoder, offset + 0, depth)?;
1361            self.1.encode(encoder, offset + 16, depth)?;
1362            self.2.encode(encoder, offset + 24, depth)?;
1363            Ok(())
1364        }
1365    }
1366
1367    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HostAddress {
1368        #[inline(always)]
1369        fn new_empty() -> Self {
1370            Self {
1371                address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
1372                interface: fidl::new_empty!(u64, D),
1373                ttl: fidl::new_empty!(i64, D),
1374            }
1375        }
1376
1377        #[inline]
1378        unsafe fn decode(
1379            &mut self,
1380            decoder: &mut fidl::encoding::Decoder<'_, D>,
1381            offset: usize,
1382            _depth: fidl::encoding::Depth,
1383        ) -> fidl::Result<()> {
1384            decoder.debug_check_bounds::<Self>(offset);
1385            // Verify that padding bytes are zero.
1386            fidl::decode!(
1387                fidl_fuchsia_net__common::IpAddress,
1388                D,
1389                &mut self.address,
1390                decoder,
1391                offset + 0,
1392                _depth
1393            )?;
1394            fidl::decode!(u64, D, &mut self.interface, decoder, offset + 16, _depth)?;
1395            fidl::decode!(i64, D, &mut self.ttl, decoder, offset + 24, _depth)?;
1396            Ok(())
1397        }
1398    }
1399
1400    impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameRequest {
1401        type Borrowed<'a> = &'a Self;
1402        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1403            value
1404        }
1405    }
1406
1407    unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameRequest {
1408        type Owned = Self;
1409
1410        #[inline(always)]
1411        fn inline_align(_context: fidl::encoding::Context) -> usize {
1412            8
1413        }
1414
1415        #[inline(always)]
1416        fn inline_size(_context: fidl::encoding::Context) -> usize {
1417            40
1418        }
1419    }
1420
1421    unsafe impl<D: fidl::encoding::ResourceDialect>
1422        fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D>
1423        for &HostNameResolverResolveHostNameRequest
1424    {
1425        #[inline]
1426        unsafe fn encode(
1427            self,
1428            encoder: &mut fidl::encoding::Encoder<'_, D>,
1429            offset: usize,
1430            _depth: fidl::encoding::Depth,
1431        ) -> fidl::Result<()> {
1432            encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1433            // Delegate to tuple encoding.
1434            fidl::encoding::Encode::<HostNameResolverResolveHostNameRequest, D>::encode(
1435                (
1436                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1437                        &self.host,
1438                    ),
1439                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
1440                    <HostNameResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(
1441                        &self.options,
1442                    ),
1443                ),
1444                encoder,
1445                offset,
1446                _depth,
1447            )
1448        }
1449    }
1450    unsafe impl<
1451            D: fidl::encoding::ResourceDialect,
1452            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1453            T1: fidl::encoding::Encode<i64, D>,
1454            T2: fidl::encoding::Encode<HostNameResolutionOptions, D>,
1455        > fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D> for (T0, T1, T2)
1456    {
1457        #[inline]
1458        unsafe fn encode(
1459            self,
1460            encoder: &mut fidl::encoding::Encoder<'_, D>,
1461            offset: usize,
1462            depth: fidl::encoding::Depth,
1463        ) -> fidl::Result<()> {
1464            encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1465            // Zero out padding regions. There's no need to apply masks
1466            // because the unmasked parts will be overwritten by fields.
1467            // Write the fields.
1468            self.0.encode(encoder, offset + 0, depth)?;
1469            self.1.encode(encoder, offset + 16, depth)?;
1470            self.2.encode(encoder, offset + 24, depth)?;
1471            Ok(())
1472        }
1473    }
1474
1475    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1476        for HostNameResolverResolveHostNameRequest
1477    {
1478        #[inline(always)]
1479        fn new_empty() -> Self {
1480            Self {
1481                host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
1482                timeout: fidl::new_empty!(i64, D),
1483                options: fidl::new_empty!(HostNameResolutionOptions, D),
1484            }
1485        }
1486
1487        #[inline]
1488        unsafe fn decode(
1489            &mut self,
1490            decoder: &mut fidl::encoding::Decoder<'_, D>,
1491            offset: usize,
1492            _depth: fidl::encoding::Depth,
1493        ) -> fidl::Result<()> {
1494            decoder.debug_check_bounds::<Self>(offset);
1495            // Verify that padding bytes are zero.
1496            fidl::decode!(
1497                fidl::encoding::BoundedString<255>,
1498                D,
1499                &mut self.host,
1500                decoder,
1501                offset + 0,
1502                _depth
1503            )?;
1504            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
1505            fidl::decode!(
1506                HostNameResolutionOptions,
1507                D,
1508                &mut self.options,
1509                decoder,
1510                offset + 24,
1511                _depth
1512            )?;
1513            Ok(())
1514        }
1515    }
1516
1517    impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameResponse {
1518        type Borrowed<'a> = &'a Self;
1519        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1520            value
1521        }
1522    }
1523
1524    unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameResponse {
1525        type Owned = Self;
1526
1527        #[inline(always)]
1528        fn inline_align(_context: fidl::encoding::Context) -> usize {
1529            8
1530        }
1531
1532        #[inline(always)]
1533        fn inline_size(_context: fidl::encoding::Context) -> usize {
1534            16
1535        }
1536    }
1537
1538    unsafe impl<D: fidl::encoding::ResourceDialect>
1539        fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D>
1540        for &HostNameResolverResolveHostNameResponse
1541    {
1542        #[inline]
1543        unsafe fn encode(
1544            self,
1545            encoder: &mut fidl::encoding::Encoder<'_, D>,
1546            offset: usize,
1547            _depth: fidl::encoding::Depth,
1548        ) -> fidl::Result<()> {
1549            encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1550            // Delegate to tuple encoding.
1551            fidl::encoding::Encode::<HostNameResolverResolveHostNameResponse, D>::encode(
1552                (
1553                    <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1554                ),
1555                encoder, offset, _depth
1556            )
1557        }
1558    }
1559    unsafe impl<
1560            D: fidl::encoding::ResourceDialect,
1561            T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1562        > fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D> for (T0,)
1563    {
1564        #[inline]
1565        unsafe fn encode(
1566            self,
1567            encoder: &mut fidl::encoding::Encoder<'_, D>,
1568            offset: usize,
1569            depth: fidl::encoding::Depth,
1570        ) -> fidl::Result<()> {
1571            encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1572            // Zero out padding regions. There's no need to apply masks
1573            // because the unmasked parts will be overwritten by fields.
1574            // Write the fields.
1575            self.0.encode(encoder, offset + 0, depth)?;
1576            Ok(())
1577        }
1578    }
1579
1580    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1581        for HostNameResolverResolveHostNameResponse
1582    {
1583        #[inline(always)]
1584        fn new_empty() -> Self {
1585            Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1586        }
1587
1588        #[inline]
1589        unsafe fn decode(
1590            &mut self,
1591            decoder: &mut fidl::encoding::Decoder<'_, D>,
1592            offset: usize,
1593            _depth: fidl::encoding::Depth,
1594        ) -> fidl::Result<()> {
1595            decoder.debug_check_bounds::<Self>(offset);
1596            // Verify that padding bytes are zero.
1597            fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1598            Ok(())
1599        }
1600    }
1601
1602    impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1603        type Borrowed<'a> = &'a Self;
1604        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1605            value
1606        }
1607    }
1608
1609    unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1610        type Owned = Self;
1611
1612        #[inline(always)]
1613        fn inline_align(_context: fidl::encoding::Context) -> usize {
1614            8
1615        }
1616
1617        #[inline(always)]
1618        fn inline_size(_context: fidl::encoding::Context) -> usize {
1619            16
1620        }
1621    }
1622
1623    unsafe impl<D: fidl::encoding::ResourceDialect>
1624        fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1625        for &HostNameSubscriptionListenerOnAddressesChangedRequest
1626    {
1627        #[inline]
1628        unsafe fn encode(
1629            self,
1630            encoder: &mut fidl::encoding::Encoder<'_, D>,
1631            offset: usize,
1632            _depth: fidl::encoding::Depth,
1633        ) -> fidl::Result<()> {
1634            encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1635                offset,
1636            );
1637            // Delegate to tuple encoding.
1638            fidl::encoding::Encode::<HostNameSubscriptionListenerOnAddressesChangedRequest, D>::encode(
1639                (
1640                    <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1641                ),
1642                encoder, offset, _depth
1643            )
1644        }
1645    }
1646    unsafe impl<
1647            D: fidl::encoding::ResourceDialect,
1648            T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1649        > fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1650        for (T0,)
1651    {
1652        #[inline]
1653        unsafe fn encode(
1654            self,
1655            encoder: &mut fidl::encoding::Encoder<'_, D>,
1656            offset: usize,
1657            depth: fidl::encoding::Depth,
1658        ) -> fidl::Result<()> {
1659            encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1660                offset,
1661            );
1662            // Zero out padding regions. There's no need to apply masks
1663            // because the unmasked parts will be overwritten by fields.
1664            // Write the fields.
1665            self.0.encode(encoder, offset + 0, depth)?;
1666            Ok(())
1667        }
1668    }
1669
1670    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1671        for HostNameSubscriptionListenerOnAddressesChangedRequest
1672    {
1673        #[inline(always)]
1674        fn new_empty() -> Self {
1675            Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1676        }
1677
1678        #[inline]
1679        unsafe fn decode(
1680            &mut self,
1681            decoder: &mut fidl::encoding::Decoder<'_, D>,
1682            offset: usize,
1683            _depth: fidl::encoding::Depth,
1684        ) -> fidl::Result<()> {
1685            decoder.debug_check_bounds::<Self>(offset);
1686            // Verify that padding bytes are zero.
1687            fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1688            Ok(())
1689        }
1690    }
1691
1692    impl fidl::encoding::ValueTypeMarker for Publication {
1693        type Borrowed<'a> = &'a Self;
1694        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1695            value
1696        }
1697    }
1698
1699    unsafe impl fidl::encoding::TypeMarker for Publication {
1700        type Owned = Self;
1701
1702        #[inline(always)]
1703        fn inline_align(_context: fidl::encoding::Context) -> usize {
1704            8
1705        }
1706
1707        #[inline(always)]
1708        fn inline_size(_context: fidl::encoding::Context) -> usize {
1709            56
1710        }
1711    }
1712
1713    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Publication, D>
1714        for &Publication
1715    {
1716        #[inline]
1717        unsafe fn encode(
1718            self,
1719            encoder: &mut fidl::encoding::Encoder<'_, D>,
1720            offset: usize,
1721            _depth: fidl::encoding::Depth,
1722        ) -> fidl::Result<()> {
1723            encoder.debug_check_bounds::<Publication>(offset);
1724            // Delegate to tuple encoding.
1725            fidl::encoding::Encode::<Publication, D>::encode(
1726                (
1727                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.port),
1728                    <fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.text),
1729                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_priority),
1730                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_weight),
1731                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ptr_ttl),
1732                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_ttl),
1733                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txt_ttl),
1734                ),
1735                encoder, offset, _depth
1736            )
1737        }
1738    }
1739    unsafe impl<
1740            D: fidl::encoding::ResourceDialect,
1741            T0: fidl::encoding::Encode<u16, D>,
1742            T1: fidl::encoding::Encode<
1743                fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1744                D,
1745            >,
1746            T2: fidl::encoding::Encode<u16, D>,
1747            T3: fidl::encoding::Encode<u16, D>,
1748            T4: fidl::encoding::Encode<i64, D>,
1749            T5: fidl::encoding::Encode<i64, D>,
1750            T6: fidl::encoding::Encode<i64, D>,
1751        > fidl::encoding::Encode<Publication, D> for (T0, T1, T2, T3, T4, T5, T6)
1752    {
1753        #[inline]
1754        unsafe fn encode(
1755            self,
1756            encoder: &mut fidl::encoding::Encoder<'_, D>,
1757            offset: usize,
1758            depth: fidl::encoding::Depth,
1759        ) -> fidl::Result<()> {
1760            encoder.debug_check_bounds::<Publication>(offset);
1761            // Zero out padding regions. There's no need to apply masks
1762            // because the unmasked parts will be overwritten by fields.
1763            unsafe {
1764                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1765                (ptr as *mut u64).write_unaligned(0);
1766            }
1767            unsafe {
1768                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
1769                (ptr as *mut u64).write_unaligned(0);
1770            }
1771            // Write the fields.
1772            self.0.encode(encoder, offset + 0, depth)?;
1773            self.1.encode(encoder, offset + 8, depth)?;
1774            self.2.encode(encoder, offset + 24, depth)?;
1775            self.3.encode(encoder, offset + 26, depth)?;
1776            self.4.encode(encoder, offset + 32, depth)?;
1777            self.5.encode(encoder, offset + 40, depth)?;
1778            self.6.encode(encoder, offset + 48, depth)?;
1779            Ok(())
1780        }
1781    }
1782
1783    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Publication {
1784        #[inline(always)]
1785        fn new_empty() -> Self {
1786            Self {
1787                port: fidl::new_empty!(u16, D),
1788                text: fidl::new_empty!(
1789                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1790                    D
1791                ),
1792                srv_priority: fidl::new_empty!(u16, D),
1793                srv_weight: fidl::new_empty!(u16, D),
1794                ptr_ttl: fidl::new_empty!(i64, D),
1795                srv_ttl: fidl::new_empty!(i64, D),
1796                txt_ttl: fidl::new_empty!(i64, D),
1797            }
1798        }
1799
1800        #[inline]
1801        unsafe fn decode(
1802            &mut self,
1803            decoder: &mut fidl::encoding::Decoder<'_, D>,
1804            offset: usize,
1805            _depth: fidl::encoding::Depth,
1806        ) -> fidl::Result<()> {
1807            decoder.debug_check_bounds::<Self>(offset);
1808            // Verify that padding bytes are zero.
1809            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1810            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1811            let mask = 0xffffffffffff0000u64;
1812            let maskedval = padval & mask;
1813            if maskedval != 0 {
1814                return Err(fidl::Error::NonZeroPadding {
1815                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1816                });
1817            }
1818            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
1819            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1820            let mask = 0xffffffff00000000u64;
1821            let maskedval = padval & mask;
1822            if maskedval != 0 {
1823                return Err(fidl::Error::NonZeroPadding {
1824                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
1825                });
1826            }
1827            fidl::decode!(u16, D, &mut self.port, decoder, offset + 0, _depth)?;
1828            fidl::decode!(
1829                fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1830                D,
1831                &mut self.text,
1832                decoder,
1833                offset + 8,
1834                _depth
1835            )?;
1836            fidl::decode!(u16, D, &mut self.srv_priority, decoder, offset + 24, _depth)?;
1837            fidl::decode!(u16, D, &mut self.srv_weight, decoder, offset + 26, _depth)?;
1838            fidl::decode!(i64, D, &mut self.ptr_ttl, decoder, offset + 32, _depth)?;
1839            fidl::decode!(i64, D, &mut self.srv_ttl, decoder, offset + 40, _depth)?;
1840            fidl::decode!(i64, D, &mut self.txt_ttl, decoder, offset + 48, _depth)?;
1841            Ok(())
1842        }
1843    }
1844
1845    impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationRequest {
1846        type Borrowed<'a> = &'a Self;
1847        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1848            value
1849        }
1850    }
1851
1852    unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationRequest {
1853        type Owned = Self;
1854
1855        #[inline(always)]
1856        fn inline_align(_context: fidl::encoding::Context) -> usize {
1857            8
1858        }
1859
1860        #[inline(always)]
1861        fn inline_size(_context: fidl::encoding::Context) -> usize {
1862            40
1863        }
1864    }
1865
1866    unsafe impl<D: fidl::encoding::ResourceDialect>
1867        fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D>
1868        for &PublicationResponderOnPublicationRequest
1869    {
1870        #[inline]
1871        unsafe fn encode(
1872            self,
1873            encoder: &mut fidl::encoding::Encoder<'_, D>,
1874            offset: usize,
1875            _depth: fidl::encoding::Depth,
1876        ) -> fidl::Result<()> {
1877            encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1878            // Delegate to tuple encoding.
1879            fidl::encoding::Encode::<PublicationResponderOnPublicationRequest, D>::encode(
1880                (
1881                    <PublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
1882                    <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
1883                    <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
1884                ),
1885                encoder, offset, _depth
1886            )
1887        }
1888    }
1889    unsafe impl<
1890            D: fidl::encoding::ResourceDialect,
1891            T0: fidl::encoding::Encode<PublicationCause, D>,
1892            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
1893            T2: fidl::encoding::Encode<
1894                fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
1895                D,
1896            >,
1897        > fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D> for (T0, T1, T2)
1898    {
1899        #[inline]
1900        unsafe fn encode(
1901            self,
1902            encoder: &mut fidl::encoding::Encoder<'_, D>,
1903            offset: usize,
1904            depth: fidl::encoding::Depth,
1905        ) -> fidl::Result<()> {
1906            encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1907            // Zero out padding regions. There's no need to apply masks
1908            // because the unmasked parts will be overwritten by fields.
1909            unsafe {
1910                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1911                (ptr as *mut u64).write_unaligned(0);
1912            }
1913            // Write the fields.
1914            self.0.encode(encoder, offset + 0, depth)?;
1915            self.1.encode(encoder, offset + 8, depth)?;
1916            self.2.encode(encoder, offset + 24, depth)?;
1917            Ok(())
1918        }
1919    }
1920
1921    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1922        for PublicationResponderOnPublicationRequest
1923    {
1924        #[inline(always)]
1925        fn new_empty() -> Self {
1926            Self {
1927                publication_cause: fidl::new_empty!(PublicationCause, D),
1928                subtype: fidl::new_empty!(
1929                    fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
1930                    D
1931                ),
1932                source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
1933            }
1934        }
1935
1936        #[inline]
1937        unsafe fn decode(
1938            &mut self,
1939            decoder: &mut fidl::encoding::Decoder<'_, D>,
1940            offset: usize,
1941            _depth: fidl::encoding::Depth,
1942        ) -> fidl::Result<()> {
1943            decoder.debug_check_bounds::<Self>(offset);
1944            // Verify that padding bytes are zero.
1945            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1946            let padval = unsafe { (ptr as *const u64).read_unaligned() };
1947            let mask = 0xffffffff00000000u64;
1948            let maskedval = padval & mask;
1949            if maskedval != 0 {
1950                return Err(fidl::Error::NonZeroPadding {
1951                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1952                });
1953            }
1954            fidl::decode!(
1955                PublicationCause,
1956                D,
1957                &mut self.publication_cause,
1958                decoder,
1959                offset + 0,
1960                _depth
1961            )?;
1962            fidl::decode!(
1963                fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
1964                D,
1965                &mut self.subtype,
1966                decoder,
1967                offset + 8,
1968                _depth
1969            )?;
1970            fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
1971            Ok(())
1972        }
1973    }
1974
1975    impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationResponse {
1976        type Borrowed<'a> = &'a Self;
1977        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978            value
1979        }
1980    }
1981
1982    unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationResponse {
1983        type Owned = Self;
1984
1985        #[inline(always)]
1986        fn inline_align(_context: fidl::encoding::Context) -> usize {
1987            8
1988        }
1989
1990        #[inline(always)]
1991        fn inline_size(_context: fidl::encoding::Context) -> usize {
1992            8
1993        }
1994    }
1995
1996    unsafe impl<D: fidl::encoding::ResourceDialect>
1997        fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D>
1998        for &PublicationResponderOnPublicationResponse
1999    {
2000        #[inline]
2001        unsafe fn encode(
2002            self,
2003            encoder: &mut fidl::encoding::Encoder<'_, D>,
2004            offset: usize,
2005            _depth: fidl::encoding::Depth,
2006        ) -> fidl::Result<()> {
2007            encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2008            // Delegate to tuple encoding.
2009            fidl::encoding::Encode::<PublicationResponderOnPublicationResponse, D>::encode(
2010                (<fidl::encoding::Boxed<Publication> as fidl::encoding::ValueTypeMarker>::borrow(
2011                    &self.publication,
2012                ),),
2013                encoder,
2014                offset,
2015                _depth,
2016            )
2017        }
2018    }
2019    unsafe impl<
2020            D: fidl::encoding::ResourceDialect,
2021            T0: fidl::encoding::Encode<fidl::encoding::Boxed<Publication>, D>,
2022        > fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D> for (T0,)
2023    {
2024        #[inline]
2025        unsafe fn encode(
2026            self,
2027            encoder: &mut fidl::encoding::Encoder<'_, D>,
2028            offset: usize,
2029            depth: fidl::encoding::Depth,
2030        ) -> fidl::Result<()> {
2031            encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2032            // Zero out padding regions. There's no need to apply masks
2033            // because the unmasked parts will be overwritten by fields.
2034            // Write the fields.
2035            self.0.encode(encoder, offset + 0, depth)?;
2036            Ok(())
2037        }
2038    }
2039
2040    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2041        for PublicationResponderOnPublicationResponse
2042    {
2043        #[inline(always)]
2044        fn new_empty() -> Self {
2045            Self { publication: fidl::new_empty!(fidl::encoding::Boxed<Publication>, D) }
2046        }
2047
2048        #[inline]
2049        unsafe fn decode(
2050            &mut self,
2051            decoder: &mut fidl::encoding::Decoder<'_, D>,
2052            offset: usize,
2053            _depth: fidl::encoding::Depth,
2054        ) -> fidl::Result<()> {
2055            decoder.debug_check_bounds::<Self>(offset);
2056            // Verify that padding bytes are zero.
2057            fidl::decode!(
2058                fidl::encoding::Boxed<Publication>,
2059                D,
2060                &mut self.publication,
2061                decoder,
2062                offset + 0,
2063                _depth
2064            )?;
2065            Ok(())
2066        }
2067    }
2068
2069    impl fidl::encoding::ValueTypeMarker for PublicationResponderSetSubtypesRequest {
2070        type Borrowed<'a> = &'a Self;
2071        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2072            value
2073        }
2074    }
2075
2076    unsafe impl fidl::encoding::TypeMarker for PublicationResponderSetSubtypesRequest {
2077        type Owned = Self;
2078
2079        #[inline(always)]
2080        fn inline_align(_context: fidl::encoding::Context) -> usize {
2081            8
2082        }
2083
2084        #[inline(always)]
2085        fn inline_size(_context: fidl::encoding::Context) -> usize {
2086            16
2087        }
2088    }
2089
2090    unsafe impl<D: fidl::encoding::ResourceDialect>
2091        fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D>
2092        for &PublicationResponderSetSubtypesRequest
2093    {
2094        #[inline]
2095        unsafe fn encode(
2096            self,
2097            encoder: &mut fidl::encoding::Encoder<'_, D>,
2098            offset: usize,
2099            _depth: fidl::encoding::Depth,
2100        ) -> fidl::Result<()> {
2101            encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2102            // Delegate to tuple encoding.
2103            fidl::encoding::Encode::<PublicationResponderSetSubtypesRequest, D>::encode(
2104                (
2105                    <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2106                ),
2107                encoder, offset, _depth
2108            )
2109        }
2110    }
2111    unsafe impl<
2112            D: fidl::encoding::ResourceDialect,
2113            T0: fidl::encoding::Encode<
2114                fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2115                D,
2116            >,
2117        > fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D> for (T0,)
2118    {
2119        #[inline]
2120        unsafe fn encode(
2121            self,
2122            encoder: &mut fidl::encoding::Encoder<'_, D>,
2123            offset: usize,
2124            depth: fidl::encoding::Depth,
2125        ) -> fidl::Result<()> {
2126            encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2127            // Zero out padding regions. There's no need to apply masks
2128            // because the unmasked parts will be overwritten by fields.
2129            // Write the fields.
2130            self.0.encode(encoder, offset + 0, depth)?;
2131            Ok(())
2132        }
2133    }
2134
2135    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2136        for PublicationResponderSetSubtypesRequest
2137    {
2138        #[inline(always)]
2139        fn new_empty() -> Self {
2140            Self {
2141                subtypes: fidl::new_empty!(
2142                    fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2143                    D
2144                ),
2145            }
2146        }
2147
2148        #[inline]
2149        unsafe fn decode(
2150            &mut self,
2151            decoder: &mut fidl::encoding::Decoder<'_, D>,
2152            offset: usize,
2153            _depth: fidl::encoding::Depth,
2154        ) -> fidl::Result<()> {
2155            decoder.debug_check_bounds::<Self>(offset);
2156            // Verify that padding bytes are zero.
2157            fidl::decode!(
2158                fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2159                D,
2160                &mut self.subtypes,
2161                decoder,
2162                offset + 0,
2163                _depth
2164            )?;
2165            Ok(())
2166        }
2167    }
2168
2169    impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameRequest {
2170        type Borrowed<'a> = &'a Self;
2171        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2172            value
2173        }
2174    }
2175
2176    unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameRequest {
2177        type Owned = Self;
2178
2179        #[inline(always)]
2180        fn inline_align(_context: fidl::encoding::Context) -> usize {
2181            8
2182        }
2183
2184        #[inline(always)]
2185        fn inline_size(_context: fidl::encoding::Context) -> usize {
2186            24
2187        }
2188    }
2189
2190    unsafe impl<D: fidl::encoding::ResourceDialect>
2191        fidl::encoding::Encode<ResolverResolveHostNameRequest, D>
2192        for &ResolverResolveHostNameRequest
2193    {
2194        #[inline]
2195        unsafe fn encode(
2196            self,
2197            encoder: &mut fidl::encoding::Encoder<'_, D>,
2198            offset: usize,
2199            _depth: fidl::encoding::Depth,
2200        ) -> fidl::Result<()> {
2201            encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2202            // Delegate to tuple encoding.
2203            fidl::encoding::Encode::<ResolverResolveHostNameRequest, D>::encode(
2204                (
2205                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
2206                        &self.host,
2207                    ),
2208                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2209                ),
2210                encoder,
2211                offset,
2212                _depth,
2213            )
2214        }
2215    }
2216    unsafe impl<
2217            D: fidl::encoding::ResourceDialect,
2218            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2219            T1: fidl::encoding::Encode<i64, D>,
2220        > fidl::encoding::Encode<ResolverResolveHostNameRequest, D> for (T0, T1)
2221    {
2222        #[inline]
2223        unsafe fn encode(
2224            self,
2225            encoder: &mut fidl::encoding::Encoder<'_, D>,
2226            offset: usize,
2227            depth: fidl::encoding::Depth,
2228        ) -> fidl::Result<()> {
2229            encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2230            // Zero out padding regions. There's no need to apply masks
2231            // because the unmasked parts will be overwritten by fields.
2232            // Write the fields.
2233            self.0.encode(encoder, offset + 0, depth)?;
2234            self.1.encode(encoder, offset + 16, depth)?;
2235            Ok(())
2236        }
2237    }
2238
2239    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2240        for ResolverResolveHostNameRequest
2241    {
2242        #[inline(always)]
2243        fn new_empty() -> Self {
2244            Self {
2245                host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2246                timeout: fidl::new_empty!(i64, D),
2247            }
2248        }
2249
2250        #[inline]
2251        unsafe fn decode(
2252            &mut self,
2253            decoder: &mut fidl::encoding::Decoder<'_, D>,
2254            offset: usize,
2255            _depth: fidl::encoding::Depth,
2256        ) -> fidl::Result<()> {
2257            decoder.debug_check_bounds::<Self>(offset);
2258            // Verify that padding bytes are zero.
2259            fidl::decode!(
2260                fidl::encoding::BoundedString<255>,
2261                D,
2262                &mut self.host,
2263                decoder,
2264                offset + 0,
2265                _depth
2266            )?;
2267            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
2268            Ok(())
2269        }
2270    }
2271
2272    impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameResponse {
2273        type Borrowed<'a> = &'a Self;
2274        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2275            value
2276        }
2277    }
2278
2279    unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameResponse {
2280        type Owned = Self;
2281
2282        #[inline(always)]
2283        fn inline_align(_context: fidl::encoding::Context) -> usize {
2284            8
2285        }
2286
2287        #[inline(always)]
2288        fn inline_size(_context: fidl::encoding::Context) -> usize {
2289            16
2290        }
2291    }
2292
2293    unsafe impl<D: fidl::encoding::ResourceDialect>
2294        fidl::encoding::Encode<ResolverResolveHostNameResponse, D>
2295        for &ResolverResolveHostNameResponse
2296    {
2297        #[inline]
2298        unsafe fn encode(
2299            self,
2300            encoder: &mut fidl::encoding::Encoder<'_, D>,
2301            offset: usize,
2302            _depth: fidl::encoding::Depth,
2303        ) -> fidl::Result<()> {
2304            encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2305            // Delegate to tuple encoding.
2306            fidl::encoding::Encode::<ResolverResolveHostNameResponse, D>::encode(
2307                (
2308                    <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v4_address),
2309                    <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v6_address),
2310                ),
2311                encoder, offset, _depth
2312            )
2313        }
2314    }
2315    unsafe impl<
2316            D: fidl::encoding::ResourceDialect,
2317            T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>, D>,
2318            T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>, D>,
2319        > fidl::encoding::Encode<ResolverResolveHostNameResponse, D> for (T0, T1)
2320    {
2321        #[inline]
2322        unsafe fn encode(
2323            self,
2324            encoder: &mut fidl::encoding::Encoder<'_, D>,
2325            offset: usize,
2326            depth: fidl::encoding::Depth,
2327        ) -> fidl::Result<()> {
2328            encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2329            // Zero out padding regions. There's no need to apply masks
2330            // because the unmasked parts will be overwritten by fields.
2331            // Write the fields.
2332            self.0.encode(encoder, offset + 0, depth)?;
2333            self.1.encode(encoder, offset + 8, depth)?;
2334            Ok(())
2335        }
2336    }
2337
2338    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2339        for ResolverResolveHostNameResponse
2340    {
2341        #[inline(always)]
2342        fn new_empty() -> Self {
2343            Self {
2344                v4_address: fidl::new_empty!(
2345                    fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2346                    D
2347                ),
2348                v6_address: fidl::new_empty!(
2349                    fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2350                    D
2351                ),
2352            }
2353        }
2354
2355        #[inline]
2356        unsafe fn decode(
2357            &mut self,
2358            decoder: &mut fidl::encoding::Decoder<'_, D>,
2359            offset: usize,
2360            _depth: fidl::encoding::Depth,
2361        ) -> fidl::Result<()> {
2362            decoder.debug_check_bounds::<Self>(offset);
2363            // Verify that padding bytes are zero.
2364            fidl::decode!(
2365                fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2366                D,
2367                &mut self.v4_address,
2368                decoder,
2369                offset + 0,
2370                _depth
2371            )?;
2372            fidl::decode!(
2373                fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2374                D,
2375                &mut self.v6_address,
2376                decoder,
2377                offset + 8,
2378                _depth
2379            )?;
2380            Ok(())
2381        }
2382    }
2383
2384    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2385        type Borrowed<'a> = &'a Self;
2386        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2387            value
2388        }
2389    }
2390
2391    unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2392        type Owned = Self;
2393
2394        #[inline(always)]
2395        fn inline_align(_context: fidl::encoding::Context) -> usize {
2396            8
2397        }
2398
2399        #[inline(always)]
2400        fn inline_size(_context: fidl::encoding::Context) -> usize {
2401            40
2402        }
2403    }
2404
2405    unsafe impl<D: fidl::encoding::ResourceDialect>
2406        fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2407        for &ServiceInstancePublicationResponderOnPublicationRequest
2408    {
2409        #[inline]
2410        unsafe fn encode(
2411            self,
2412            encoder: &mut fidl::encoding::Encoder<'_, D>,
2413            offset: usize,
2414            _depth: fidl::encoding::Depth,
2415        ) -> fidl::Result<()> {
2416            encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2417                offset,
2418            );
2419            // Delegate to tuple encoding.
2420            fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationRequest, D>::encode(
2421                (
2422                    <ServiceInstancePublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
2423                    <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
2424                    <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
2425                ),
2426                encoder, offset, _depth
2427            )
2428        }
2429    }
2430    unsafe impl<
2431            D: fidl::encoding::ResourceDialect,
2432            T0: fidl::encoding::Encode<ServiceInstancePublicationCause, D>,
2433            T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
2434            T2: fidl::encoding::Encode<
2435                fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
2436                D,
2437            >,
2438        > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2439        for (T0, T1, T2)
2440    {
2441        #[inline]
2442        unsafe fn encode(
2443            self,
2444            encoder: &mut fidl::encoding::Encoder<'_, D>,
2445            offset: usize,
2446            depth: fidl::encoding::Depth,
2447        ) -> fidl::Result<()> {
2448            encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2449                offset,
2450            );
2451            // Zero out padding regions. There's no need to apply masks
2452            // because the unmasked parts will be overwritten by fields.
2453            unsafe {
2454                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2455                (ptr as *mut u64).write_unaligned(0);
2456            }
2457            // Write the fields.
2458            self.0.encode(encoder, offset + 0, depth)?;
2459            self.1.encode(encoder, offset + 8, depth)?;
2460            self.2.encode(encoder, offset + 24, depth)?;
2461            Ok(())
2462        }
2463    }
2464
2465    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2466        for ServiceInstancePublicationResponderOnPublicationRequest
2467    {
2468        #[inline(always)]
2469        fn new_empty() -> Self {
2470            Self {
2471                publication_cause: fidl::new_empty!(ServiceInstancePublicationCause, D),
2472                subtype: fidl::new_empty!(
2473                    fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2474                    D
2475                ),
2476                source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
2477            }
2478        }
2479
2480        #[inline]
2481        unsafe fn decode(
2482            &mut self,
2483            decoder: &mut fidl::encoding::Decoder<'_, D>,
2484            offset: usize,
2485            _depth: fidl::encoding::Depth,
2486        ) -> fidl::Result<()> {
2487            decoder.debug_check_bounds::<Self>(offset);
2488            // Verify that padding bytes are zero.
2489            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2490            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2491            let mask = 0xffffffff00000000u64;
2492            let maskedval = padval & mask;
2493            if maskedval != 0 {
2494                return Err(fidl::Error::NonZeroPadding {
2495                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2496                });
2497            }
2498            fidl::decode!(
2499                ServiceInstancePublicationCause,
2500                D,
2501                &mut self.publication_cause,
2502                decoder,
2503                offset + 0,
2504                _depth
2505            )?;
2506            fidl::decode!(
2507                fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2508                D,
2509                &mut self.subtype,
2510                decoder,
2511                offset + 8,
2512                _depth
2513            )?;
2514            fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
2515            Ok(())
2516        }
2517    }
2518
2519    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2520        type Borrowed<'a> = &'a Self;
2521        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2522            value
2523        }
2524    }
2525
2526    unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2527        type Owned = Self;
2528
2529        #[inline(always)]
2530        fn inline_align(_context: fidl::encoding::Context) -> usize {
2531            8
2532        }
2533
2534        #[inline(always)]
2535        fn inline_size(_context: fidl::encoding::Context) -> usize {
2536            16
2537        }
2538    }
2539
2540    unsafe impl<D: fidl::encoding::ResourceDialect>
2541        fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2542        for &ServiceInstancePublicationResponderSetSubtypesRequest
2543    {
2544        #[inline]
2545        unsafe fn encode(
2546            self,
2547            encoder: &mut fidl::encoding::Encoder<'_, D>,
2548            offset: usize,
2549            _depth: fidl::encoding::Depth,
2550        ) -> fidl::Result<()> {
2551            encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2552                offset,
2553            );
2554            // Delegate to tuple encoding.
2555            fidl::encoding::Encode::<ServiceInstancePublicationResponderSetSubtypesRequest, D>::encode(
2556                (
2557                    <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2558                ),
2559                encoder, offset, _depth
2560            )
2561        }
2562    }
2563    unsafe impl<
2564            D: fidl::encoding::ResourceDialect,
2565            T0: fidl::encoding::Encode<
2566                fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2567                D,
2568            >,
2569        > fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2570        for (T0,)
2571    {
2572        #[inline]
2573        unsafe fn encode(
2574            self,
2575            encoder: &mut fidl::encoding::Encoder<'_, D>,
2576            offset: usize,
2577            depth: fidl::encoding::Depth,
2578        ) -> fidl::Result<()> {
2579            encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2580                offset,
2581            );
2582            // Zero out padding regions. There's no need to apply masks
2583            // because the unmasked parts will be overwritten by fields.
2584            // Write the fields.
2585            self.0.encode(encoder, offset + 0, depth)?;
2586            Ok(())
2587        }
2588    }
2589
2590    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2591        for ServiceInstancePublicationResponderSetSubtypesRequest
2592    {
2593        #[inline(always)]
2594        fn new_empty() -> Self {
2595            Self {
2596                subtypes: fidl::new_empty!(
2597                    fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2598                    D
2599                ),
2600            }
2601        }
2602
2603        #[inline]
2604        unsafe fn decode(
2605            &mut self,
2606            decoder: &mut fidl::encoding::Decoder<'_, D>,
2607            offset: usize,
2608            _depth: fidl::encoding::Depth,
2609        ) -> fidl::Result<()> {
2610            decoder.debug_check_bounds::<Self>(offset);
2611            // Verify that padding bytes are zero.
2612            fidl::decode!(
2613                fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2614                D,
2615                &mut self.subtypes,
2616                decoder,
2617                offset + 0,
2618                _depth
2619            )?;
2620            Ok(())
2621        }
2622    }
2623
2624    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationResponse {
2625        type Borrowed<'a> = &'a Self;
2626        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2627            value
2628        }
2629    }
2630
2631    unsafe impl fidl::encoding::TypeMarker
2632        for ServiceInstancePublicationResponderOnPublicationResponse
2633    {
2634        type Owned = Self;
2635
2636        #[inline(always)]
2637        fn inline_align(_context: fidl::encoding::Context) -> usize {
2638            8
2639        }
2640
2641        #[inline(always)]
2642        fn inline_size(_context: fidl::encoding::Context) -> usize {
2643            16
2644        }
2645    }
2646
2647    unsafe impl<D: fidl::encoding::ResourceDialect>
2648        fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2649        for &ServiceInstancePublicationResponderOnPublicationResponse
2650    {
2651        #[inline]
2652        unsafe fn encode(
2653            self,
2654            encoder: &mut fidl::encoding::Encoder<'_, D>,
2655            offset: usize,
2656            _depth: fidl::encoding::Depth,
2657        ) -> fidl::Result<()> {
2658            encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2659                offset,
2660            );
2661            // Delegate to tuple encoding.
2662            fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationResponse, D>::encode(
2663                (
2664                    <ServiceInstancePublication as fidl::encoding::ValueTypeMarker>::borrow(&self.publication),
2665                ),
2666                encoder, offset, _depth
2667            )
2668        }
2669    }
2670    unsafe impl<
2671            D: fidl::encoding::ResourceDialect,
2672            T0: fidl::encoding::Encode<ServiceInstancePublication, D>,
2673        > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2674        for (T0,)
2675    {
2676        #[inline]
2677        unsafe fn encode(
2678            self,
2679            encoder: &mut fidl::encoding::Encoder<'_, D>,
2680            offset: usize,
2681            depth: fidl::encoding::Depth,
2682        ) -> fidl::Result<()> {
2683            encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2684                offset,
2685            );
2686            // Zero out padding regions. There's no need to apply masks
2687            // because the unmasked parts will be overwritten by fields.
2688            // Write the fields.
2689            self.0.encode(encoder, offset + 0, depth)?;
2690            Ok(())
2691        }
2692    }
2693
2694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2695        for ServiceInstancePublicationResponderOnPublicationResponse
2696    {
2697        #[inline(always)]
2698        fn new_empty() -> Self {
2699            Self { publication: fidl::new_empty!(ServiceInstancePublication, D) }
2700        }
2701
2702        #[inline]
2703        unsafe fn decode(
2704            &mut self,
2705            decoder: &mut fidl::encoding::Decoder<'_, D>,
2706            offset: usize,
2707            _depth: fidl::encoding::Depth,
2708        ) -> fidl::Result<()> {
2709            decoder.debug_check_bounds::<Self>(offset);
2710            // Verify that padding bytes are zero.
2711            fidl::decode!(
2712                ServiceInstancePublication,
2713                D,
2714                &mut self.publication,
2715                decoder,
2716                offset + 0,
2717                _depth
2718            )?;
2719            Ok(())
2720        }
2721    }
2722
2723    impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2724        type Borrowed<'a> = &'a Self;
2725        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2726            value
2727        }
2728    }
2729
2730    unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2731        type Owned = Self;
2732
2733        #[inline(always)]
2734        fn inline_align(_context: fidl::encoding::Context) -> usize {
2735            8
2736        }
2737
2738        #[inline(always)]
2739        fn inline_size(_context: fidl::encoding::Context) -> usize {
2740            56
2741        }
2742    }
2743
2744    unsafe impl<D: fidl::encoding::ResourceDialect>
2745        fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2746        for &ServiceInstanceResolverResolveServiceInstanceRequest
2747    {
2748        #[inline]
2749        unsafe fn encode(
2750            self,
2751            encoder: &mut fidl::encoding::Encoder<'_, D>,
2752            offset: usize,
2753            _depth: fidl::encoding::Depth,
2754        ) -> fidl::Result<()> {
2755            encoder
2756                .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2757            // Delegate to tuple encoding.
2758            fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceRequest, D>::encode(
2759                (
2760                    <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(&self.service),
2761                    <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2762                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2763                    <ServiceInstanceResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2764                ),
2765                encoder, offset, _depth
2766            )
2767        }
2768    }
2769    unsafe impl<
2770            D: fidl::encoding::ResourceDialect,
2771            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
2772            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
2773            T2: fidl::encoding::Encode<i64, D>,
2774            T3: fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>,
2775        > fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2776        for (T0, T1, T2, T3)
2777    {
2778        #[inline]
2779        unsafe fn encode(
2780            self,
2781            encoder: &mut fidl::encoding::Encoder<'_, D>,
2782            offset: usize,
2783            depth: fidl::encoding::Depth,
2784        ) -> fidl::Result<()> {
2785            encoder
2786                .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2787            // Zero out padding regions. There's no need to apply masks
2788            // because the unmasked parts will be overwritten by fields.
2789            // Write the fields.
2790            self.0.encode(encoder, offset + 0, depth)?;
2791            self.1.encode(encoder, offset + 16, depth)?;
2792            self.2.encode(encoder, offset + 32, depth)?;
2793            self.3.encode(encoder, offset + 40, depth)?;
2794            Ok(())
2795        }
2796    }
2797
2798    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2799        for ServiceInstanceResolverResolveServiceInstanceRequest
2800    {
2801        #[inline(always)]
2802        fn new_empty() -> Self {
2803            Self {
2804                service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
2805                instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
2806                timeout: fidl::new_empty!(i64, D),
2807                options: fidl::new_empty!(ServiceInstanceResolutionOptions, D),
2808            }
2809        }
2810
2811        #[inline]
2812        unsafe fn decode(
2813            &mut self,
2814            decoder: &mut fidl::encoding::Decoder<'_, D>,
2815            offset: usize,
2816            _depth: fidl::encoding::Depth,
2817        ) -> fidl::Result<()> {
2818            decoder.debug_check_bounds::<Self>(offset);
2819            // Verify that padding bytes are zero.
2820            fidl::decode!(
2821                fidl::encoding::BoundedString<22>,
2822                D,
2823                &mut self.service,
2824                decoder,
2825                offset + 0,
2826                _depth
2827            )?;
2828            fidl::decode!(
2829                fidl::encoding::BoundedString<63>,
2830                D,
2831                &mut self.instance,
2832                decoder,
2833                offset + 16,
2834                _depth
2835            )?;
2836            fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 32, _depth)?;
2837            fidl::decode!(
2838                ServiceInstanceResolutionOptions,
2839                D,
2840                &mut self.options,
2841                decoder,
2842                offset + 40,
2843                _depth
2844            )?;
2845            Ok(())
2846        }
2847    }
2848
2849    impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2850        type Borrowed<'a> = &'a Self;
2851        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2852            value
2853        }
2854    }
2855
2856    unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2857        type Owned = Self;
2858
2859        #[inline(always)]
2860        fn inline_align(_context: fidl::encoding::Context) -> usize {
2861            8
2862        }
2863
2864        #[inline(always)]
2865        fn inline_size(_context: fidl::encoding::Context) -> usize {
2866            16
2867        }
2868    }
2869
2870    unsafe impl<D: fidl::encoding::ResourceDialect>
2871        fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D>
2872        for &ServiceInstanceResolverResolveServiceInstanceResponse
2873    {
2874        #[inline]
2875        unsafe fn encode(
2876            self,
2877            encoder: &mut fidl::encoding::Encoder<'_, D>,
2878            offset: usize,
2879            _depth: fidl::encoding::Depth,
2880        ) -> fidl::Result<()> {
2881            encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2882                offset,
2883            );
2884            // Delegate to tuple encoding.
2885            fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceResponse, D>::encode(
2886                (
2887                    <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2888                ),
2889                encoder, offset, _depth
2890            )
2891        }
2892    }
2893    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
2894        fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D> for (T0,)
2895    {
2896        #[inline]
2897        unsafe fn encode(
2898            self,
2899            encoder: &mut fidl::encoding::Encoder<'_, D>,
2900            offset: usize,
2901            depth: fidl::encoding::Depth,
2902        ) -> fidl::Result<()> {
2903            encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2904                offset,
2905            );
2906            // Zero out padding regions. There's no need to apply masks
2907            // because the unmasked parts will be overwritten by fields.
2908            // Write the fields.
2909            self.0.encode(encoder, offset + 0, depth)?;
2910            Ok(())
2911        }
2912    }
2913
2914    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2915        for ServiceInstanceResolverResolveServiceInstanceResponse
2916    {
2917        #[inline(always)]
2918        fn new_empty() -> Self {
2919            Self { instance: fidl::new_empty!(ServiceInstance, D) }
2920        }
2921
2922        #[inline]
2923        unsafe fn decode(
2924            &mut self,
2925            decoder: &mut fidl::encoding::Decoder<'_, D>,
2926            offset: usize,
2927            _depth: fidl::encoding::Depth,
2928        ) -> fidl::Result<()> {
2929            decoder.debug_check_bounds::<Self>(offset);
2930            // Verify that padding bytes are zero.
2931            fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
2932            Ok(())
2933        }
2934    }
2935
2936    impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceChangedRequest {
2937        type Borrowed<'a> = &'a Self;
2938        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2939            value
2940        }
2941    }
2942
2943    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceChangedRequest {
2944        type Owned = Self;
2945
2946        #[inline(always)]
2947        fn inline_align(_context: fidl::encoding::Context) -> usize {
2948            8
2949        }
2950
2951        #[inline(always)]
2952        fn inline_size(_context: fidl::encoding::Context) -> usize {
2953            16
2954        }
2955    }
2956
2957    unsafe impl<D: fidl::encoding::ResourceDialect>
2958        fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D>
2959        for &ServiceSubscriberOnInstanceChangedRequest
2960    {
2961        #[inline]
2962        unsafe fn encode(
2963            self,
2964            encoder: &mut fidl::encoding::Encoder<'_, D>,
2965            offset: usize,
2966            _depth: fidl::encoding::Depth,
2967        ) -> fidl::Result<()> {
2968            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
2969            // Delegate to tuple encoding.
2970            fidl::encoding::Encode::<ServiceSubscriberOnInstanceChangedRequest, D>::encode(
2971                (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
2972                encoder,
2973                offset,
2974                _depth,
2975            )
2976        }
2977    }
2978    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
2979        fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D> for (T0,)
2980    {
2981        #[inline]
2982        unsafe fn encode(
2983            self,
2984            encoder: &mut fidl::encoding::Encoder<'_, D>,
2985            offset: usize,
2986            depth: fidl::encoding::Depth,
2987        ) -> fidl::Result<()> {
2988            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
2989            // Zero out padding regions. There's no need to apply masks
2990            // because the unmasked parts will be overwritten by fields.
2991            // Write the fields.
2992            self.0.encode(encoder, offset + 0, depth)?;
2993            Ok(())
2994        }
2995    }
2996
2997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2998        for ServiceSubscriberOnInstanceChangedRequest
2999    {
3000        #[inline(always)]
3001        fn new_empty() -> Self {
3002            Self { instance: fidl::new_empty!(ServiceInstance, D) }
3003        }
3004
3005        #[inline]
3006        unsafe fn decode(
3007            &mut self,
3008            decoder: &mut fidl::encoding::Decoder<'_, D>,
3009            offset: usize,
3010            _depth: fidl::encoding::Depth,
3011        ) -> fidl::Result<()> {
3012            decoder.debug_check_bounds::<Self>(offset);
3013            // Verify that padding bytes are zero.
3014            fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3015            Ok(())
3016        }
3017    }
3018
3019    impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3020        type Borrowed<'a> = &'a Self;
3021        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3022            value
3023        }
3024    }
3025
3026    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3027        type Owned = Self;
3028
3029        #[inline(always)]
3030        fn inline_align(_context: fidl::encoding::Context) -> usize {
3031            8
3032        }
3033
3034        #[inline(always)]
3035        fn inline_size(_context: fidl::encoding::Context) -> usize {
3036            16
3037        }
3038    }
3039
3040    unsafe impl<D: fidl::encoding::ResourceDialect>
3041        fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D>
3042        for &ServiceSubscriberOnInstanceDiscoveredRequest
3043    {
3044        #[inline]
3045        unsafe fn encode(
3046            self,
3047            encoder: &mut fidl::encoding::Encoder<'_, D>,
3048            offset: usize,
3049            _depth: fidl::encoding::Depth,
3050        ) -> fidl::Result<()> {
3051            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3052            // Delegate to tuple encoding.
3053            fidl::encoding::Encode::<ServiceSubscriberOnInstanceDiscoveredRequest, D>::encode(
3054                (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3055                encoder,
3056                offset,
3057                _depth,
3058            )
3059        }
3060    }
3061    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3062        fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D> for (T0,)
3063    {
3064        #[inline]
3065        unsafe fn encode(
3066            self,
3067            encoder: &mut fidl::encoding::Encoder<'_, D>,
3068            offset: usize,
3069            depth: fidl::encoding::Depth,
3070        ) -> fidl::Result<()> {
3071            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3072            // Zero out padding regions. There's no need to apply masks
3073            // because the unmasked parts will be overwritten by fields.
3074            // Write the fields.
3075            self.0.encode(encoder, offset + 0, depth)?;
3076            Ok(())
3077        }
3078    }
3079
3080    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3081        for ServiceSubscriberOnInstanceDiscoveredRequest
3082    {
3083        #[inline(always)]
3084        fn new_empty() -> Self {
3085            Self { instance: fidl::new_empty!(ServiceInstance, D) }
3086        }
3087
3088        #[inline]
3089        unsafe fn decode(
3090            &mut self,
3091            decoder: &mut fidl::encoding::Decoder<'_, D>,
3092            offset: usize,
3093            _depth: fidl::encoding::Depth,
3094        ) -> fidl::Result<()> {
3095            decoder.debug_check_bounds::<Self>(offset);
3096            // Verify that padding bytes are zero.
3097            fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3098            Ok(())
3099        }
3100    }
3101
3102    impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceLostRequest {
3103        type Borrowed<'a> = &'a Self;
3104        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3105            value
3106        }
3107    }
3108
3109    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceLostRequest {
3110        type Owned = Self;
3111
3112        #[inline(always)]
3113        fn inline_align(_context: fidl::encoding::Context) -> usize {
3114            8
3115        }
3116
3117        #[inline(always)]
3118        fn inline_size(_context: fidl::encoding::Context) -> usize {
3119            32
3120        }
3121    }
3122
3123    unsafe impl<D: fidl::encoding::ResourceDialect>
3124        fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D>
3125        for &ServiceSubscriberOnInstanceLostRequest
3126    {
3127        #[inline]
3128        unsafe fn encode(
3129            self,
3130            encoder: &mut fidl::encoding::Encoder<'_, D>,
3131            offset: usize,
3132            _depth: fidl::encoding::Depth,
3133        ) -> fidl::Result<()> {
3134            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3135            // Delegate to tuple encoding.
3136            fidl::encoding::Encode::<ServiceSubscriberOnInstanceLostRequest, D>::encode(
3137                (
3138                    <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3139                        &self.service,
3140                    ),
3141                    <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3142                        &self.instance,
3143                    ),
3144                ),
3145                encoder,
3146                offset,
3147                _depth,
3148            )
3149        }
3150    }
3151    unsafe impl<
3152            D: fidl::encoding::ResourceDialect,
3153            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3154            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3155        > fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D> for (T0, T1)
3156    {
3157        #[inline]
3158        unsafe fn encode(
3159            self,
3160            encoder: &mut fidl::encoding::Encoder<'_, D>,
3161            offset: usize,
3162            depth: fidl::encoding::Depth,
3163        ) -> fidl::Result<()> {
3164            encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3165            // Zero out padding regions. There's no need to apply masks
3166            // because the unmasked parts will be overwritten by fields.
3167            // Write the fields.
3168            self.0.encode(encoder, offset + 0, depth)?;
3169            self.1.encode(encoder, offset + 16, depth)?;
3170            Ok(())
3171        }
3172    }
3173
3174    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3175        for ServiceSubscriberOnInstanceLostRequest
3176    {
3177        #[inline(always)]
3178        fn new_empty() -> Self {
3179            Self {
3180                service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3181                instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3182            }
3183        }
3184
3185        #[inline]
3186        unsafe fn decode(
3187            &mut self,
3188            decoder: &mut fidl::encoding::Decoder<'_, D>,
3189            offset: usize,
3190            _depth: fidl::encoding::Depth,
3191        ) -> fidl::Result<()> {
3192            decoder.debug_check_bounds::<Self>(offset);
3193            // Verify that padding bytes are zero.
3194            fidl::decode!(
3195                fidl::encoding::BoundedString<22>,
3196                D,
3197                &mut self.service,
3198                decoder,
3199                offset + 0,
3200                _depth
3201            )?;
3202            fidl::decode!(
3203                fidl::encoding::BoundedString<63>,
3204                D,
3205                &mut self.instance,
3206                decoder,
3207                offset + 16,
3208                _depth
3209            )?;
3210            Ok(())
3211        }
3212    }
3213
3214    impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnQueryRequest {
3215        type Borrowed<'a> = &'a Self;
3216        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3217            value
3218        }
3219    }
3220
3221    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnQueryRequest {
3222        type Owned = Self;
3223
3224        #[inline(always)]
3225        fn inline_align(_context: fidl::encoding::Context) -> usize {
3226            4
3227        }
3228
3229        #[inline(always)]
3230        fn inline_size(_context: fidl::encoding::Context) -> usize {
3231            4
3232        }
3233    }
3234
3235    unsafe impl<D: fidl::encoding::ResourceDialect>
3236        fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D>
3237        for &ServiceSubscriberOnQueryRequest
3238    {
3239        #[inline]
3240        unsafe fn encode(
3241            self,
3242            encoder: &mut fidl::encoding::Encoder<'_, D>,
3243            offset: usize,
3244            _depth: fidl::encoding::Depth,
3245        ) -> fidl::Result<()> {
3246            encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3247            // Delegate to tuple encoding.
3248            fidl::encoding::Encode::<ServiceSubscriberOnQueryRequest, D>::encode(
3249                (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3250                encoder,
3251                offset,
3252                _depth,
3253            )
3254        }
3255    }
3256    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3257        fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D> for (T0,)
3258    {
3259        #[inline]
3260        unsafe fn encode(
3261            self,
3262            encoder: &mut fidl::encoding::Encoder<'_, D>,
3263            offset: usize,
3264            depth: fidl::encoding::Depth,
3265        ) -> fidl::Result<()> {
3266            encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3267            // Zero out padding regions. There's no need to apply masks
3268            // because the unmasked parts will be overwritten by fields.
3269            // Write the fields.
3270            self.0.encode(encoder, offset + 0, depth)?;
3271            Ok(())
3272        }
3273    }
3274
3275    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3276        for ServiceSubscriberOnQueryRequest
3277    {
3278        #[inline(always)]
3279        fn new_empty() -> Self {
3280            Self { resource_type: fidl::new_empty!(ResourceType, D) }
3281        }
3282
3283        #[inline]
3284        unsafe fn decode(
3285            &mut self,
3286            decoder: &mut fidl::encoding::Decoder<'_, D>,
3287            offset: usize,
3288            _depth: fidl::encoding::Depth,
3289        ) -> fidl::Result<()> {
3290            decoder.debug_check_bounds::<Self>(offset);
3291            // Verify that padding bytes are zero.
3292            fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3293            Ok(())
3294        }
3295    }
3296
3297    impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3298        type Borrowed<'a> = &'a Self;
3299        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3300            value
3301        }
3302    }
3303
3304    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3305        type Owned = Self;
3306
3307        #[inline(always)]
3308        fn inline_align(_context: fidl::encoding::Context) -> usize {
3309            8
3310        }
3311
3312        #[inline(always)]
3313        fn inline_size(_context: fidl::encoding::Context) -> usize {
3314            16
3315        }
3316    }
3317
3318    unsafe impl<D: fidl::encoding::ResourceDialect>
3319        fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D>
3320        for &ServiceSubscriptionListenerOnInstanceChangedRequest
3321    {
3322        #[inline]
3323        unsafe fn encode(
3324            self,
3325            encoder: &mut fidl::encoding::Encoder<'_, D>,
3326            offset: usize,
3327            _depth: fidl::encoding::Depth,
3328        ) -> fidl::Result<()> {
3329            encoder
3330                .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3331            // Delegate to tuple encoding.
3332            fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceChangedRequest, D>::encode(
3333                (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3334                encoder,
3335                offset,
3336                _depth,
3337            )
3338        }
3339    }
3340    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3341        fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D> for (T0,)
3342    {
3343        #[inline]
3344        unsafe fn encode(
3345            self,
3346            encoder: &mut fidl::encoding::Encoder<'_, D>,
3347            offset: usize,
3348            depth: fidl::encoding::Depth,
3349        ) -> fidl::Result<()> {
3350            encoder
3351                .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3352            // Zero out padding regions. There's no need to apply masks
3353            // because the unmasked parts will be overwritten by fields.
3354            // Write the fields.
3355            self.0.encode(encoder, offset + 0, depth)?;
3356            Ok(())
3357        }
3358    }
3359
3360    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3361        for ServiceSubscriptionListenerOnInstanceChangedRequest
3362    {
3363        #[inline(always)]
3364        fn new_empty() -> Self {
3365            Self { instance: fidl::new_empty!(ServiceInstance, D) }
3366        }
3367
3368        #[inline]
3369        unsafe fn decode(
3370            &mut self,
3371            decoder: &mut fidl::encoding::Decoder<'_, D>,
3372            offset: usize,
3373            _depth: fidl::encoding::Depth,
3374        ) -> fidl::Result<()> {
3375            decoder.debug_check_bounds::<Self>(offset);
3376            // Verify that padding bytes are zero.
3377            fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3378            Ok(())
3379        }
3380    }
3381
3382    impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3383        type Borrowed<'a> = &'a Self;
3384        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3385            value
3386        }
3387    }
3388
3389    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3390        type Owned = Self;
3391
3392        #[inline(always)]
3393        fn inline_align(_context: fidl::encoding::Context) -> usize {
3394            8
3395        }
3396
3397        #[inline(always)]
3398        fn inline_size(_context: fidl::encoding::Context) -> usize {
3399            16
3400        }
3401    }
3402
3403    unsafe impl<D: fidl::encoding::ResourceDialect>
3404        fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>
3405        for &ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3406    {
3407        #[inline]
3408        unsafe fn encode(
3409            self,
3410            encoder: &mut fidl::encoding::Encoder<'_, D>,
3411            offset: usize,
3412            _depth: fidl::encoding::Depth,
3413        ) -> fidl::Result<()> {
3414            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3415                offset,
3416            );
3417            // Delegate to tuple encoding.
3418            fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>::encode(
3419                (
3420                    <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
3421                ),
3422                encoder, offset, _depth
3423            )
3424        }
3425    }
3426    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3427        fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D> for (T0,)
3428    {
3429        #[inline]
3430        unsafe fn encode(
3431            self,
3432            encoder: &mut fidl::encoding::Encoder<'_, D>,
3433            offset: usize,
3434            depth: fidl::encoding::Depth,
3435        ) -> fidl::Result<()> {
3436            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3437                offset,
3438            );
3439            // Zero out padding regions. There's no need to apply masks
3440            // because the unmasked parts will be overwritten by fields.
3441            // Write the fields.
3442            self.0.encode(encoder, offset + 0, depth)?;
3443            Ok(())
3444        }
3445    }
3446
3447    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3448        for ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3449    {
3450        #[inline(always)]
3451        fn new_empty() -> Self {
3452            Self { instance: fidl::new_empty!(ServiceInstance, D) }
3453        }
3454
3455        #[inline]
3456        unsafe fn decode(
3457            &mut self,
3458            decoder: &mut fidl::encoding::Decoder<'_, D>,
3459            offset: usize,
3460            _depth: fidl::encoding::Depth,
3461        ) -> fidl::Result<()> {
3462            decoder.debug_check_bounds::<Self>(offset);
3463            // Verify that padding bytes are zero.
3464            fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3465            Ok(())
3466        }
3467    }
3468
3469    impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3470        type Borrowed<'a> = &'a Self;
3471        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3472            value
3473        }
3474    }
3475
3476    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3477        type Owned = Self;
3478
3479        #[inline(always)]
3480        fn inline_align(_context: fidl::encoding::Context) -> usize {
3481            8
3482        }
3483
3484        #[inline(always)]
3485        fn inline_size(_context: fidl::encoding::Context) -> usize {
3486            32
3487        }
3488    }
3489
3490    unsafe impl<D: fidl::encoding::ResourceDialect>
3491        fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D>
3492        for &ServiceSubscriptionListenerOnInstanceLostRequest
3493    {
3494        #[inline]
3495        unsafe fn encode(
3496            self,
3497            encoder: &mut fidl::encoding::Encoder<'_, D>,
3498            offset: usize,
3499            _depth: fidl::encoding::Depth,
3500        ) -> fidl::Result<()> {
3501            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3502            // Delegate to tuple encoding.
3503            fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceLostRequest, D>::encode(
3504                (
3505                    <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3506                        &self.service,
3507                    ),
3508                    <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3509                        &self.instance,
3510                    ),
3511                ),
3512                encoder,
3513                offset,
3514                _depth,
3515            )
3516        }
3517    }
3518    unsafe impl<
3519            D: fidl::encoding::ResourceDialect,
3520            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3521            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3522        > fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D> for (T0, T1)
3523    {
3524        #[inline]
3525        unsafe fn encode(
3526            self,
3527            encoder: &mut fidl::encoding::Encoder<'_, D>,
3528            offset: usize,
3529            depth: fidl::encoding::Depth,
3530        ) -> fidl::Result<()> {
3531            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3532            // Zero out padding regions. There's no need to apply masks
3533            // because the unmasked parts will be overwritten by fields.
3534            // Write the fields.
3535            self.0.encode(encoder, offset + 0, depth)?;
3536            self.1.encode(encoder, offset + 16, depth)?;
3537            Ok(())
3538        }
3539    }
3540
3541    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3542        for ServiceSubscriptionListenerOnInstanceLostRequest
3543    {
3544        #[inline(always)]
3545        fn new_empty() -> Self {
3546            Self {
3547                service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3548                instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3549            }
3550        }
3551
3552        #[inline]
3553        unsafe fn decode(
3554            &mut self,
3555            decoder: &mut fidl::encoding::Decoder<'_, D>,
3556            offset: usize,
3557            _depth: fidl::encoding::Depth,
3558        ) -> fidl::Result<()> {
3559            decoder.debug_check_bounds::<Self>(offset);
3560            // Verify that padding bytes are zero.
3561            fidl::decode!(
3562                fidl::encoding::BoundedString<22>,
3563                D,
3564                &mut self.service,
3565                decoder,
3566                offset + 0,
3567                _depth
3568            )?;
3569            fidl::decode!(
3570                fidl::encoding::BoundedString<63>,
3571                D,
3572                &mut self.instance,
3573                decoder,
3574                offset + 16,
3575                _depth
3576            )?;
3577            Ok(())
3578        }
3579    }
3580
3581    impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3582        type Borrowed<'a> = &'a Self;
3583        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3584            value
3585        }
3586    }
3587
3588    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3589        type Owned = Self;
3590
3591        #[inline(always)]
3592        fn inline_align(_context: fidl::encoding::Context) -> usize {
3593            4
3594        }
3595
3596        #[inline(always)]
3597        fn inline_size(_context: fidl::encoding::Context) -> usize {
3598            4
3599        }
3600    }
3601
3602    unsafe impl<D: fidl::encoding::ResourceDialect>
3603        fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D>
3604        for &ServiceSubscriptionListenerOnQueryRequest
3605    {
3606        #[inline]
3607        unsafe fn encode(
3608            self,
3609            encoder: &mut fidl::encoding::Encoder<'_, D>,
3610            offset: usize,
3611            _depth: fidl::encoding::Depth,
3612        ) -> fidl::Result<()> {
3613            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3614            // Delegate to tuple encoding.
3615            fidl::encoding::Encode::<ServiceSubscriptionListenerOnQueryRequest, D>::encode(
3616                (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3617                encoder,
3618                offset,
3619                _depth,
3620            )
3621        }
3622    }
3623    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3624        fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D> for (T0,)
3625    {
3626        #[inline]
3627        unsafe fn encode(
3628            self,
3629            encoder: &mut fidl::encoding::Encoder<'_, D>,
3630            offset: usize,
3631            depth: fidl::encoding::Depth,
3632        ) -> fidl::Result<()> {
3633            encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3634            // Zero out padding regions. There's no need to apply masks
3635            // because the unmasked parts will be overwritten by fields.
3636            // Write the fields.
3637            self.0.encode(encoder, offset + 0, depth)?;
3638            Ok(())
3639        }
3640    }
3641
3642    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3643        for ServiceSubscriptionListenerOnQueryRequest
3644    {
3645        #[inline(always)]
3646        fn new_empty() -> Self {
3647            Self { resource_type: fidl::new_empty!(ResourceType, D) }
3648        }
3649
3650        #[inline]
3651        unsafe fn decode(
3652            &mut self,
3653            decoder: &mut fidl::encoding::Decoder<'_, D>,
3654            offset: usize,
3655            _depth: fidl::encoding::Depth,
3656        ) -> fidl::Result<()> {
3657            decoder.debug_check_bounds::<Self>(offset);
3658            // Verify that padding bytes are zero.
3659            fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3660            Ok(())
3661        }
3662    }
3663
3664    impl HostNameResolutionOptions {
3665        #[inline(always)]
3666        fn max_ordinal_present(&self) -> u64 {
3667            if let Some(_) = self.exclude_local_proxies {
3668                return 4;
3669            }
3670            if let Some(_) = self.exclude_local {
3671                return 3;
3672            }
3673            if let Some(_) = self.ip_versions {
3674                return 2;
3675            }
3676            if let Some(_) = self.media {
3677                return 1;
3678            }
3679            0
3680        }
3681    }
3682
3683    impl fidl::encoding::ValueTypeMarker for HostNameResolutionOptions {
3684        type Borrowed<'a> = &'a Self;
3685        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3686            value
3687        }
3688    }
3689
3690    unsafe impl fidl::encoding::TypeMarker for HostNameResolutionOptions {
3691        type Owned = Self;
3692
3693        #[inline(always)]
3694        fn inline_align(_context: fidl::encoding::Context) -> usize {
3695            8
3696        }
3697
3698        #[inline(always)]
3699        fn inline_size(_context: fidl::encoding::Context) -> usize {
3700            16
3701        }
3702    }
3703
3704    unsafe impl<D: fidl::encoding::ResourceDialect>
3705        fidl::encoding::Encode<HostNameResolutionOptions, D> for &HostNameResolutionOptions
3706    {
3707        unsafe fn encode(
3708            self,
3709            encoder: &mut fidl::encoding::Encoder<'_, D>,
3710            offset: usize,
3711            mut depth: fidl::encoding::Depth,
3712        ) -> fidl::Result<()> {
3713            encoder.debug_check_bounds::<HostNameResolutionOptions>(offset);
3714            // Vector header
3715            let max_ordinal: u64 = self.max_ordinal_present();
3716            encoder.write_num(max_ordinal, offset);
3717            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3718            // Calling encoder.out_of_line_offset(0) is not allowed.
3719            if max_ordinal == 0 {
3720                return Ok(());
3721            }
3722            depth.increment()?;
3723            let envelope_size = 8;
3724            let bytes_len = max_ordinal as usize * envelope_size;
3725            #[allow(unused_variables)]
3726            let offset = encoder.out_of_line_offset(bytes_len);
3727            let mut _prev_end_offset: usize = 0;
3728            if 1 > max_ordinal {
3729                return Ok(());
3730            }
3731
3732            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3733            // are envelope_size bytes.
3734            let cur_offset: usize = (1 - 1) * envelope_size;
3735
3736            // Zero reserved fields.
3737            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3738
3739            // Safety:
3740            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3741            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3742            //   envelope_size bytes, there is always sufficient room.
3743            fidl::encoding::encode_in_envelope_optional::<Media, D>(
3744                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
3745                encoder,
3746                offset + cur_offset,
3747                depth,
3748            )?;
3749
3750            _prev_end_offset = cur_offset + envelope_size;
3751            if 2 > max_ordinal {
3752                return Ok(());
3753            }
3754
3755            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3756            // are envelope_size bytes.
3757            let cur_offset: usize = (2 - 1) * envelope_size;
3758
3759            // Zero reserved fields.
3760            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3761
3762            // Safety:
3763            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3764            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3765            //   envelope_size bytes, there is always sufficient room.
3766            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
3767                self.ip_versions
3768                    .as_ref()
3769                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
3770                encoder,
3771                offset + cur_offset,
3772                depth,
3773            )?;
3774
3775            _prev_end_offset = cur_offset + envelope_size;
3776            if 3 > max_ordinal {
3777                return Ok(());
3778            }
3779
3780            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3781            // are envelope_size bytes.
3782            let cur_offset: usize = (3 - 1) * envelope_size;
3783
3784            // Zero reserved fields.
3785            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3786
3787            // Safety:
3788            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3789            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3790            //   envelope_size bytes, there is always sufficient room.
3791            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3792                self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3793                encoder,
3794                offset + cur_offset,
3795                depth,
3796            )?;
3797
3798            _prev_end_offset = cur_offset + envelope_size;
3799            if 4 > max_ordinal {
3800                return Ok(());
3801            }
3802
3803            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3804            // are envelope_size bytes.
3805            let cur_offset: usize = (4 - 1) * envelope_size;
3806
3807            // Zero reserved fields.
3808            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3809
3810            // Safety:
3811            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3812            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3813            //   envelope_size bytes, there is always sufficient room.
3814            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3815                self.exclude_local_proxies
3816                    .as_ref()
3817                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3818                encoder,
3819                offset + cur_offset,
3820                depth,
3821            )?;
3822
3823            _prev_end_offset = cur_offset + envelope_size;
3824
3825            Ok(())
3826        }
3827    }
3828
3829    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3830        for HostNameResolutionOptions
3831    {
3832        #[inline(always)]
3833        fn new_empty() -> Self {
3834            Self::default()
3835        }
3836
3837        unsafe fn decode(
3838            &mut self,
3839            decoder: &mut fidl::encoding::Decoder<'_, D>,
3840            offset: usize,
3841            mut depth: fidl::encoding::Depth,
3842        ) -> fidl::Result<()> {
3843            decoder.debug_check_bounds::<Self>(offset);
3844            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3845                None => return Err(fidl::Error::NotNullable),
3846                Some(len) => len,
3847            };
3848            // Calling decoder.out_of_line_offset(0) is not allowed.
3849            if len == 0 {
3850                return Ok(());
3851            };
3852            depth.increment()?;
3853            let envelope_size = 8;
3854            let bytes_len = len * envelope_size;
3855            let offset = decoder.out_of_line_offset(bytes_len)?;
3856            // Decode the envelope for each type.
3857            let mut _next_ordinal_to_read = 0;
3858            let mut next_offset = offset;
3859            let end_offset = offset + bytes_len;
3860            _next_ordinal_to_read += 1;
3861            if next_offset >= end_offset {
3862                return Ok(());
3863            }
3864
3865            // Decode unknown envelopes for gaps in ordinals.
3866            while _next_ordinal_to_read < 1 {
3867                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3868                _next_ordinal_to_read += 1;
3869                next_offset += envelope_size;
3870            }
3871
3872            let next_out_of_line = decoder.next_out_of_line();
3873            let handles_before = decoder.remaining_handles();
3874            if let Some((inlined, num_bytes, num_handles)) =
3875                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3876            {
3877                let member_inline_size =
3878                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3879                if inlined != (member_inline_size <= 4) {
3880                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3881                }
3882                let inner_offset;
3883                let mut inner_depth = depth.clone();
3884                if inlined {
3885                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3886                    inner_offset = next_offset;
3887                } else {
3888                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3889                    inner_depth.increment()?;
3890                }
3891                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
3892                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
3893                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3894                {
3895                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3896                }
3897                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3898                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3899                }
3900            }
3901
3902            next_offset += envelope_size;
3903            _next_ordinal_to_read += 1;
3904            if next_offset >= end_offset {
3905                return Ok(());
3906            }
3907
3908            // Decode unknown envelopes for gaps in ordinals.
3909            while _next_ordinal_to_read < 2 {
3910                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3911                _next_ordinal_to_read += 1;
3912                next_offset += envelope_size;
3913            }
3914
3915            let next_out_of_line = decoder.next_out_of_line();
3916            let handles_before = decoder.remaining_handles();
3917            if let Some((inlined, num_bytes, num_handles)) =
3918                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3919            {
3920                let member_inline_size =
3921                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3922                if inlined != (member_inline_size <= 4) {
3923                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3924                }
3925                let inner_offset;
3926                let mut inner_depth = depth.clone();
3927                if inlined {
3928                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3929                    inner_offset = next_offset;
3930                } else {
3931                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3932                    inner_depth.increment()?;
3933                }
3934                let val_ref =
3935                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
3936                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
3937                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3938                {
3939                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3940                }
3941                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3942                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3943                }
3944            }
3945
3946            next_offset += envelope_size;
3947            _next_ordinal_to_read += 1;
3948            if next_offset >= end_offset {
3949                return Ok(());
3950            }
3951
3952            // Decode unknown envelopes for gaps in ordinals.
3953            while _next_ordinal_to_read < 3 {
3954                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3955                _next_ordinal_to_read += 1;
3956                next_offset += envelope_size;
3957            }
3958
3959            let next_out_of_line = decoder.next_out_of_line();
3960            let handles_before = decoder.remaining_handles();
3961            if let Some((inlined, num_bytes, num_handles)) =
3962                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3963            {
3964                let member_inline_size =
3965                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3966                if inlined != (member_inline_size <= 4) {
3967                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3968                }
3969                let inner_offset;
3970                let mut inner_depth = depth.clone();
3971                if inlined {
3972                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3973                    inner_offset = next_offset;
3974                } else {
3975                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3976                    inner_depth.increment()?;
3977                }
3978                let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
3979                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3980                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3981                {
3982                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3983                }
3984                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3985                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3986                }
3987            }
3988
3989            next_offset += envelope_size;
3990            _next_ordinal_to_read += 1;
3991            if next_offset >= end_offset {
3992                return Ok(());
3993            }
3994
3995            // Decode unknown envelopes for gaps in ordinals.
3996            while _next_ordinal_to_read < 4 {
3997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3998                _next_ordinal_to_read += 1;
3999                next_offset += envelope_size;
4000            }
4001
4002            let next_out_of_line = decoder.next_out_of_line();
4003            let handles_before = decoder.remaining_handles();
4004            if let Some((inlined, num_bytes, num_handles)) =
4005                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4006            {
4007                let member_inline_size =
4008                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4009                if inlined != (member_inline_size <= 4) {
4010                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4011                }
4012                let inner_offset;
4013                let mut inner_depth = depth.clone();
4014                if inlined {
4015                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4016                    inner_offset = next_offset;
4017                } else {
4018                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4019                    inner_depth.increment()?;
4020                }
4021                let val_ref =
4022                    self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4023                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4024                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4025                {
4026                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4027                }
4028                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4029                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4030                }
4031            }
4032
4033            next_offset += envelope_size;
4034
4035            // Decode the remaining unknown envelopes.
4036            while next_offset < end_offset {
4037                _next_ordinal_to_read += 1;
4038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4039                next_offset += envelope_size;
4040            }
4041
4042            Ok(())
4043        }
4044    }
4045
4046    impl HostNameSubscriptionOptions {
4047        #[inline(always)]
4048        fn max_ordinal_present(&self) -> u64 {
4049            if let Some(_) = self.exclude_local_proxies {
4050                return 4;
4051            }
4052            if let Some(_) = self.exclude_local {
4053                return 3;
4054            }
4055            if let Some(_) = self.ip_versions {
4056                return 2;
4057            }
4058            if let Some(_) = self.media {
4059                return 1;
4060            }
4061            0
4062        }
4063    }
4064
4065    impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionOptions {
4066        type Borrowed<'a> = &'a Self;
4067        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4068            value
4069        }
4070    }
4071
4072    unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionOptions {
4073        type Owned = Self;
4074
4075        #[inline(always)]
4076        fn inline_align(_context: fidl::encoding::Context) -> usize {
4077            8
4078        }
4079
4080        #[inline(always)]
4081        fn inline_size(_context: fidl::encoding::Context) -> usize {
4082            16
4083        }
4084    }
4085
4086    unsafe impl<D: fidl::encoding::ResourceDialect>
4087        fidl::encoding::Encode<HostNameSubscriptionOptions, D> for &HostNameSubscriptionOptions
4088    {
4089        unsafe fn encode(
4090            self,
4091            encoder: &mut fidl::encoding::Encoder<'_, D>,
4092            offset: usize,
4093            mut depth: fidl::encoding::Depth,
4094        ) -> fidl::Result<()> {
4095            encoder.debug_check_bounds::<HostNameSubscriptionOptions>(offset);
4096            // Vector header
4097            let max_ordinal: u64 = self.max_ordinal_present();
4098            encoder.write_num(max_ordinal, offset);
4099            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4100            // Calling encoder.out_of_line_offset(0) is not allowed.
4101            if max_ordinal == 0 {
4102                return Ok(());
4103            }
4104            depth.increment()?;
4105            let envelope_size = 8;
4106            let bytes_len = max_ordinal as usize * envelope_size;
4107            #[allow(unused_variables)]
4108            let offset = encoder.out_of_line_offset(bytes_len);
4109            let mut _prev_end_offset: usize = 0;
4110            if 1 > max_ordinal {
4111                return Ok(());
4112            }
4113
4114            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4115            // are envelope_size bytes.
4116            let cur_offset: usize = (1 - 1) * envelope_size;
4117
4118            // Zero reserved fields.
4119            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4120
4121            // Safety:
4122            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4123            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4124            //   envelope_size bytes, there is always sufficient room.
4125            fidl::encoding::encode_in_envelope_optional::<Media, D>(
4126                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4127                encoder,
4128                offset + cur_offset,
4129                depth,
4130            )?;
4131
4132            _prev_end_offset = cur_offset + envelope_size;
4133            if 2 > max_ordinal {
4134                return Ok(());
4135            }
4136
4137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4138            // are envelope_size bytes.
4139            let cur_offset: usize = (2 - 1) * envelope_size;
4140
4141            // Zero reserved fields.
4142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4143
4144            // Safety:
4145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4147            //   envelope_size bytes, there is always sufficient room.
4148            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4149                self.ip_versions
4150                    .as_ref()
4151                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4152                encoder,
4153                offset + cur_offset,
4154                depth,
4155            )?;
4156
4157            _prev_end_offset = cur_offset + envelope_size;
4158            if 3 > max_ordinal {
4159                return Ok(());
4160            }
4161
4162            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4163            // are envelope_size bytes.
4164            let cur_offset: usize = (3 - 1) * envelope_size;
4165
4166            // Zero reserved fields.
4167            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4168
4169            // Safety:
4170            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4171            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4172            //   envelope_size bytes, there is always sufficient room.
4173            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4174                self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4175                encoder,
4176                offset + cur_offset,
4177                depth,
4178            )?;
4179
4180            _prev_end_offset = cur_offset + envelope_size;
4181            if 4 > max_ordinal {
4182                return Ok(());
4183            }
4184
4185            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4186            // are envelope_size bytes.
4187            let cur_offset: usize = (4 - 1) * envelope_size;
4188
4189            // Zero reserved fields.
4190            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4191
4192            // Safety:
4193            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4194            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4195            //   envelope_size bytes, there is always sufficient room.
4196            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4197                self.exclude_local_proxies
4198                    .as_ref()
4199                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4200                encoder,
4201                offset + cur_offset,
4202                depth,
4203            )?;
4204
4205            _prev_end_offset = cur_offset + envelope_size;
4206
4207            Ok(())
4208        }
4209    }
4210
4211    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4212        for HostNameSubscriptionOptions
4213    {
4214        #[inline(always)]
4215        fn new_empty() -> Self {
4216            Self::default()
4217        }
4218
4219        unsafe fn decode(
4220            &mut self,
4221            decoder: &mut fidl::encoding::Decoder<'_, D>,
4222            offset: usize,
4223            mut depth: fidl::encoding::Depth,
4224        ) -> fidl::Result<()> {
4225            decoder.debug_check_bounds::<Self>(offset);
4226            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4227                None => return Err(fidl::Error::NotNullable),
4228                Some(len) => len,
4229            };
4230            // Calling decoder.out_of_line_offset(0) is not allowed.
4231            if len == 0 {
4232                return Ok(());
4233            };
4234            depth.increment()?;
4235            let envelope_size = 8;
4236            let bytes_len = len * envelope_size;
4237            let offset = decoder.out_of_line_offset(bytes_len)?;
4238            // Decode the envelope for each type.
4239            let mut _next_ordinal_to_read = 0;
4240            let mut next_offset = offset;
4241            let end_offset = offset + bytes_len;
4242            _next_ordinal_to_read += 1;
4243            if next_offset >= end_offset {
4244                return Ok(());
4245            }
4246
4247            // Decode unknown envelopes for gaps in ordinals.
4248            while _next_ordinal_to_read < 1 {
4249                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4250                _next_ordinal_to_read += 1;
4251                next_offset += envelope_size;
4252            }
4253
4254            let next_out_of_line = decoder.next_out_of_line();
4255            let handles_before = decoder.remaining_handles();
4256            if let Some((inlined, num_bytes, num_handles)) =
4257                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4258            {
4259                let member_inline_size =
4260                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4261                if inlined != (member_inline_size <= 4) {
4262                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4263                }
4264                let inner_offset;
4265                let mut inner_depth = depth.clone();
4266                if inlined {
4267                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4268                    inner_offset = next_offset;
4269                } else {
4270                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4271                    inner_depth.increment()?;
4272                }
4273                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4274                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4275                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4276                {
4277                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4278                }
4279                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4280                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4281                }
4282            }
4283
4284            next_offset += envelope_size;
4285            _next_ordinal_to_read += 1;
4286            if next_offset >= end_offset {
4287                return Ok(());
4288            }
4289
4290            // Decode unknown envelopes for gaps in ordinals.
4291            while _next_ordinal_to_read < 2 {
4292                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4293                _next_ordinal_to_read += 1;
4294                next_offset += envelope_size;
4295            }
4296
4297            let next_out_of_line = decoder.next_out_of_line();
4298            let handles_before = decoder.remaining_handles();
4299            if let Some((inlined, num_bytes, num_handles)) =
4300                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4301            {
4302                let member_inline_size =
4303                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4304                if inlined != (member_inline_size <= 4) {
4305                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4306                }
4307                let inner_offset;
4308                let mut inner_depth = depth.clone();
4309                if inlined {
4310                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4311                    inner_offset = next_offset;
4312                } else {
4313                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4314                    inner_depth.increment()?;
4315                }
4316                let val_ref =
4317                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4318                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4319                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4320                {
4321                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4322                }
4323                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4324                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4325                }
4326            }
4327
4328            next_offset += envelope_size;
4329            _next_ordinal_to_read += 1;
4330            if next_offset >= end_offset {
4331                return Ok(());
4332            }
4333
4334            // Decode unknown envelopes for gaps in ordinals.
4335            while _next_ordinal_to_read < 3 {
4336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4337                _next_ordinal_to_read += 1;
4338                next_offset += envelope_size;
4339            }
4340
4341            let next_out_of_line = decoder.next_out_of_line();
4342            let handles_before = decoder.remaining_handles();
4343            if let Some((inlined, num_bytes, num_handles)) =
4344                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4345            {
4346                let member_inline_size =
4347                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4348                if inlined != (member_inline_size <= 4) {
4349                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4350                }
4351                let inner_offset;
4352                let mut inner_depth = depth.clone();
4353                if inlined {
4354                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4355                    inner_offset = next_offset;
4356                } else {
4357                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4358                    inner_depth.increment()?;
4359                }
4360                let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
4361                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4362                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4363                {
4364                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4365                }
4366                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4367                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4368                }
4369            }
4370
4371            next_offset += envelope_size;
4372            _next_ordinal_to_read += 1;
4373            if next_offset >= end_offset {
4374                return Ok(());
4375            }
4376
4377            // Decode unknown envelopes for gaps in ordinals.
4378            while _next_ordinal_to_read < 4 {
4379                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4380                _next_ordinal_to_read += 1;
4381                next_offset += envelope_size;
4382            }
4383
4384            let next_out_of_line = decoder.next_out_of_line();
4385            let handles_before = decoder.remaining_handles();
4386            if let Some((inlined, num_bytes, num_handles)) =
4387                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4388            {
4389                let member_inline_size =
4390                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4391                if inlined != (member_inline_size <= 4) {
4392                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4393                }
4394                let inner_offset;
4395                let mut inner_depth = depth.clone();
4396                if inlined {
4397                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4398                    inner_offset = next_offset;
4399                } else {
4400                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4401                    inner_depth.increment()?;
4402                }
4403                let val_ref =
4404                    self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4405                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4406                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4407                {
4408                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4409                }
4410                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4411                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4412                }
4413            }
4414
4415            next_offset += envelope_size;
4416
4417            // Decode the remaining unknown envelopes.
4418            while next_offset < end_offset {
4419                _next_ordinal_to_read += 1;
4420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4421                next_offset += envelope_size;
4422            }
4423
4424            Ok(())
4425        }
4426    }
4427
4428    impl ProxyHostPublicationOptions {
4429        #[inline(always)]
4430        fn max_ordinal_present(&self) -> u64 {
4431            if let Some(_) = self.perform_probe {
4432                return 3;
4433            }
4434            if let Some(_) = self.ip_versions {
4435                return 2;
4436            }
4437            if let Some(_) = self.media {
4438                return 1;
4439            }
4440            0
4441        }
4442    }
4443
4444    impl fidl::encoding::ValueTypeMarker for ProxyHostPublicationOptions {
4445        type Borrowed<'a> = &'a Self;
4446        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4447            value
4448        }
4449    }
4450
4451    unsafe impl fidl::encoding::TypeMarker for ProxyHostPublicationOptions {
4452        type Owned = Self;
4453
4454        #[inline(always)]
4455        fn inline_align(_context: fidl::encoding::Context) -> usize {
4456            8
4457        }
4458
4459        #[inline(always)]
4460        fn inline_size(_context: fidl::encoding::Context) -> usize {
4461            16
4462        }
4463    }
4464
4465    unsafe impl<D: fidl::encoding::ResourceDialect>
4466        fidl::encoding::Encode<ProxyHostPublicationOptions, D> for &ProxyHostPublicationOptions
4467    {
4468        unsafe fn encode(
4469            self,
4470            encoder: &mut fidl::encoding::Encoder<'_, D>,
4471            offset: usize,
4472            mut depth: fidl::encoding::Depth,
4473        ) -> fidl::Result<()> {
4474            encoder.debug_check_bounds::<ProxyHostPublicationOptions>(offset);
4475            // Vector header
4476            let max_ordinal: u64 = self.max_ordinal_present();
4477            encoder.write_num(max_ordinal, offset);
4478            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4479            // Calling encoder.out_of_line_offset(0) is not allowed.
4480            if max_ordinal == 0 {
4481                return Ok(());
4482            }
4483            depth.increment()?;
4484            let envelope_size = 8;
4485            let bytes_len = max_ordinal as usize * envelope_size;
4486            #[allow(unused_variables)]
4487            let offset = encoder.out_of_line_offset(bytes_len);
4488            let mut _prev_end_offset: usize = 0;
4489            if 1 > max_ordinal {
4490                return Ok(());
4491            }
4492
4493            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4494            // are envelope_size bytes.
4495            let cur_offset: usize = (1 - 1) * envelope_size;
4496
4497            // Zero reserved fields.
4498            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4499
4500            // Safety:
4501            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4502            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4503            //   envelope_size bytes, there is always sufficient room.
4504            fidl::encoding::encode_in_envelope_optional::<Media, D>(
4505                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4506                encoder,
4507                offset + cur_offset,
4508                depth,
4509            )?;
4510
4511            _prev_end_offset = cur_offset + envelope_size;
4512            if 2 > max_ordinal {
4513                return Ok(());
4514            }
4515
4516            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4517            // are envelope_size bytes.
4518            let cur_offset: usize = (2 - 1) * envelope_size;
4519
4520            // Zero reserved fields.
4521            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4522
4523            // Safety:
4524            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4525            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4526            //   envelope_size bytes, there is always sufficient room.
4527            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4528                self.ip_versions
4529                    .as_ref()
4530                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4531                encoder,
4532                offset + cur_offset,
4533                depth,
4534            )?;
4535
4536            _prev_end_offset = cur_offset + envelope_size;
4537            if 3 > max_ordinal {
4538                return Ok(());
4539            }
4540
4541            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4542            // are envelope_size bytes.
4543            let cur_offset: usize = (3 - 1) * envelope_size;
4544
4545            // Zero reserved fields.
4546            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4547
4548            // Safety:
4549            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4550            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4551            //   envelope_size bytes, there is always sufficient room.
4552            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4553                self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4554                encoder,
4555                offset + cur_offset,
4556                depth,
4557            )?;
4558
4559            _prev_end_offset = cur_offset + envelope_size;
4560
4561            Ok(())
4562        }
4563    }
4564
4565    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4566        for ProxyHostPublicationOptions
4567    {
4568        #[inline(always)]
4569        fn new_empty() -> Self {
4570            Self::default()
4571        }
4572
4573        unsafe fn decode(
4574            &mut self,
4575            decoder: &mut fidl::encoding::Decoder<'_, D>,
4576            offset: usize,
4577            mut depth: fidl::encoding::Depth,
4578        ) -> fidl::Result<()> {
4579            decoder.debug_check_bounds::<Self>(offset);
4580            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4581                None => return Err(fidl::Error::NotNullable),
4582                Some(len) => len,
4583            };
4584            // Calling decoder.out_of_line_offset(0) is not allowed.
4585            if len == 0 {
4586                return Ok(());
4587            };
4588            depth.increment()?;
4589            let envelope_size = 8;
4590            let bytes_len = len * envelope_size;
4591            let offset = decoder.out_of_line_offset(bytes_len)?;
4592            // Decode the envelope for each type.
4593            let mut _next_ordinal_to_read = 0;
4594            let mut next_offset = offset;
4595            let end_offset = offset + bytes_len;
4596            _next_ordinal_to_read += 1;
4597            if next_offset >= end_offset {
4598                return Ok(());
4599            }
4600
4601            // Decode unknown envelopes for gaps in ordinals.
4602            while _next_ordinal_to_read < 1 {
4603                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4604                _next_ordinal_to_read += 1;
4605                next_offset += envelope_size;
4606            }
4607
4608            let next_out_of_line = decoder.next_out_of_line();
4609            let handles_before = decoder.remaining_handles();
4610            if let Some((inlined, num_bytes, num_handles)) =
4611                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4612            {
4613                let member_inline_size =
4614                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4615                if inlined != (member_inline_size <= 4) {
4616                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4617                }
4618                let inner_offset;
4619                let mut inner_depth = depth.clone();
4620                if inlined {
4621                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4622                    inner_offset = next_offset;
4623                } else {
4624                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4625                    inner_depth.increment()?;
4626                }
4627                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4628                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4629                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4630                {
4631                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4632                }
4633                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4634                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4635                }
4636            }
4637
4638            next_offset += envelope_size;
4639            _next_ordinal_to_read += 1;
4640            if next_offset >= end_offset {
4641                return Ok(());
4642            }
4643
4644            // Decode unknown envelopes for gaps in ordinals.
4645            while _next_ordinal_to_read < 2 {
4646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4647                _next_ordinal_to_read += 1;
4648                next_offset += envelope_size;
4649            }
4650
4651            let next_out_of_line = decoder.next_out_of_line();
4652            let handles_before = decoder.remaining_handles();
4653            if let Some((inlined, num_bytes, num_handles)) =
4654                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4655            {
4656                let member_inline_size =
4657                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4658                if inlined != (member_inline_size <= 4) {
4659                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4660                }
4661                let inner_offset;
4662                let mut inner_depth = depth.clone();
4663                if inlined {
4664                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4665                    inner_offset = next_offset;
4666                } else {
4667                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4668                    inner_depth.increment()?;
4669                }
4670                let val_ref =
4671                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4672                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4673                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4674                {
4675                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4676                }
4677                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4678                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4679                }
4680            }
4681
4682            next_offset += envelope_size;
4683            _next_ordinal_to_read += 1;
4684            if next_offset >= end_offset {
4685                return Ok(());
4686            }
4687
4688            // Decode unknown envelopes for gaps in ordinals.
4689            while _next_ordinal_to_read < 3 {
4690                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4691                _next_ordinal_to_read += 1;
4692                next_offset += envelope_size;
4693            }
4694
4695            let next_out_of_line = decoder.next_out_of_line();
4696            let handles_before = decoder.remaining_handles();
4697            if let Some((inlined, num_bytes, num_handles)) =
4698                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4699            {
4700                let member_inline_size =
4701                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4702                if inlined != (member_inline_size <= 4) {
4703                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4704                }
4705                let inner_offset;
4706                let mut inner_depth = depth.clone();
4707                if inlined {
4708                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4709                    inner_offset = next_offset;
4710                } else {
4711                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4712                    inner_depth.increment()?;
4713                }
4714                let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
4715                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4716                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4717                {
4718                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4719                }
4720                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4721                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4722                }
4723            }
4724
4725            next_offset += envelope_size;
4726
4727            // Decode the remaining unknown envelopes.
4728            while next_offset < end_offset {
4729                _next_ordinal_to_read += 1;
4730                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4731                next_offset += envelope_size;
4732            }
4733
4734            Ok(())
4735        }
4736    }
4737
4738    impl ServiceInstance {
4739        #[inline(always)]
4740        fn max_ordinal_present(&self) -> u64 {
4741            if let Some(_) = self.text_strings {
4742                return 10;
4743            }
4744            if let Some(_) = self.addresses {
4745                return 9;
4746            }
4747            if let Some(_) = self.target {
4748                return 8;
4749            }
4750            if let Some(_) = self.srv_weight {
4751                return 7;
4752            }
4753            if let Some(_) = self.srv_priority {
4754                return 6;
4755            }
4756            if let Some(_) = self.text {
4757                return 5;
4758            }
4759            if let Some(_) = self.ipv6_endpoint {
4760                return 4;
4761            }
4762            if let Some(_) = self.ipv4_endpoint {
4763                return 3;
4764            }
4765            if let Some(_) = self.instance {
4766                return 2;
4767            }
4768            if let Some(_) = self.service {
4769                return 1;
4770            }
4771            0
4772        }
4773    }
4774
4775    impl fidl::encoding::ValueTypeMarker for ServiceInstance {
4776        type Borrowed<'a> = &'a Self;
4777        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4778            value
4779        }
4780    }
4781
4782    unsafe impl fidl::encoding::TypeMarker for ServiceInstance {
4783        type Owned = Self;
4784
4785        #[inline(always)]
4786        fn inline_align(_context: fidl::encoding::Context) -> usize {
4787            8
4788        }
4789
4790        #[inline(always)]
4791        fn inline_size(_context: fidl::encoding::Context) -> usize {
4792            16
4793        }
4794    }
4795
4796    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceInstance, D>
4797        for &ServiceInstance
4798    {
4799        unsafe fn encode(
4800            self,
4801            encoder: &mut fidl::encoding::Encoder<'_, D>,
4802            offset: usize,
4803            mut depth: fidl::encoding::Depth,
4804        ) -> fidl::Result<()> {
4805            encoder.debug_check_bounds::<ServiceInstance>(offset);
4806            // Vector header
4807            let max_ordinal: u64 = self.max_ordinal_present();
4808            encoder.write_num(max_ordinal, offset);
4809            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4810            // Calling encoder.out_of_line_offset(0) is not allowed.
4811            if max_ordinal == 0 {
4812                return Ok(());
4813            }
4814            depth.increment()?;
4815            let envelope_size = 8;
4816            let bytes_len = max_ordinal as usize * envelope_size;
4817            #[allow(unused_variables)]
4818            let offset = encoder.out_of_line_offset(bytes_len);
4819            let mut _prev_end_offset: usize = 0;
4820            if 1 > max_ordinal {
4821                return Ok(());
4822            }
4823
4824            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4825            // are envelope_size bytes.
4826            let cur_offset: usize = (1 - 1) * envelope_size;
4827
4828            // Zero reserved fields.
4829            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4830
4831            // Safety:
4832            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4833            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4834            //   envelope_size bytes, there is always sufficient room.
4835            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<22>, D>(
4836                self.service.as_ref().map(
4837                    <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow,
4838                ),
4839                encoder,
4840                offset + cur_offset,
4841                depth,
4842            )?;
4843
4844            _prev_end_offset = cur_offset + envelope_size;
4845            if 2 > max_ordinal {
4846                return Ok(());
4847            }
4848
4849            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4850            // are envelope_size bytes.
4851            let cur_offset: usize = (2 - 1) * envelope_size;
4852
4853            // Zero reserved fields.
4854            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4855
4856            // Safety:
4857            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4858            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4859            //   envelope_size bytes, there is always sufficient room.
4860            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<63>, D>(
4861                self.instance.as_ref().map(
4862                    <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow,
4863                ),
4864                encoder,
4865                offset + cur_offset,
4866                depth,
4867            )?;
4868
4869            _prev_end_offset = cur_offset + envelope_size;
4870            if 3 > max_ordinal {
4871                return Ok(());
4872            }
4873
4874            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4875            // are envelope_size bytes.
4876            let cur_offset: usize = (3 - 1) * envelope_size;
4877
4878            // Zero reserved fields.
4879            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4880
4881            // Safety:
4882            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4883            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4884            //   envelope_size bytes, there is always sufficient room.
4885            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4SocketAddress, D>(
4886            self.ipv4_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4887            encoder, offset + cur_offset, depth
4888        )?;
4889
4890            _prev_end_offset = cur_offset + envelope_size;
4891            if 4 > max_ordinal {
4892                return Ok(());
4893            }
4894
4895            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4896            // are envelope_size bytes.
4897            let cur_offset: usize = (4 - 1) * envelope_size;
4898
4899            // Zero reserved fields.
4900            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4901
4902            // Safety:
4903            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4904            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4905            //   envelope_size bytes, there is always sufficient room.
4906            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6SocketAddress, D>(
4907            self.ipv6_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4908            encoder, offset + cur_offset, depth
4909        )?;
4910
4911            _prev_end_offset = cur_offset + envelope_size;
4912            if 5 > max_ordinal {
4913                return Ok(());
4914            }
4915
4916            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4917            // are envelope_size bytes.
4918            let cur_offset: usize = (5 - 1) * envelope_size;
4919
4920            // Zero reserved fields.
4921            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4922
4923            // Safety:
4924            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4925            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4926            //   envelope_size bytes, there is always sufficient room.
4927            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>, D>(
4928            self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
4929            encoder, offset + cur_offset, depth
4930        )?;
4931
4932            _prev_end_offset = cur_offset + envelope_size;
4933            if 6 > max_ordinal {
4934                return Ok(());
4935            }
4936
4937            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4938            // are envelope_size bytes.
4939            let cur_offset: usize = (6 - 1) * envelope_size;
4940
4941            // Zero reserved fields.
4942            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4943
4944            // Safety:
4945            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4946            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4947            //   envelope_size bytes, there is always sufficient room.
4948            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4949                self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4950                encoder,
4951                offset + cur_offset,
4952                depth,
4953            )?;
4954
4955            _prev_end_offset = cur_offset + envelope_size;
4956            if 7 > max_ordinal {
4957                return Ok(());
4958            }
4959
4960            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4961            // are envelope_size bytes.
4962            let cur_offset: usize = (7 - 1) * envelope_size;
4963
4964            // Zero reserved fields.
4965            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4966
4967            // Safety:
4968            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4969            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4970            //   envelope_size bytes, there is always sufficient room.
4971            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4972                self.srv_weight.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4973                encoder,
4974                offset + cur_offset,
4975                depth,
4976            )?;
4977
4978            _prev_end_offset = cur_offset + envelope_size;
4979            if 8 > max_ordinal {
4980                return Ok(());
4981            }
4982
4983            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4984            // are envelope_size bytes.
4985            let cur_offset: usize = (8 - 1) * envelope_size;
4986
4987            // Zero reserved fields.
4988            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4989
4990            // Safety:
4991            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4992            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4993            //   envelope_size bytes, there is always sufficient room.
4994            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
4995                self.target.as_ref().map(
4996                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4997                ),
4998                encoder,
4999                offset + cur_offset,
5000                depth,
5001            )?;
5002
5003            _prev_end_offset = cur_offset + envelope_size;
5004            if 9 > max_ordinal {
5005                return Ok(());
5006            }
5007
5008            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5009            // are envelope_size bytes.
5010            let cur_offset: usize = (9 - 1) * envelope_size;
5011
5012            // Zero reserved fields.
5013            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5014
5015            // Safety:
5016            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5017            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5018            //   envelope_size bytes, there is always sufficient room.
5019            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D>(
5020            self.addresses.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5021            encoder, offset + cur_offset, depth
5022        )?;
5023
5024            _prev_end_offset = cur_offset + envelope_size;
5025            if 10 > max_ordinal {
5026                return Ok(());
5027            }
5028
5029            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5030            // are envelope_size bytes.
5031            let cur_offset: usize = (10 - 1) * envelope_size;
5032
5033            // Zero reserved fields.
5034            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5035
5036            // Safety:
5037            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5038            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5039            //   envelope_size bytes, there is always sufficient room.
5040            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5041            self.text_strings.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5042            encoder, offset + cur_offset, depth
5043        )?;
5044
5045            _prev_end_offset = cur_offset + envelope_size;
5046
5047            Ok(())
5048        }
5049    }
5050
5051    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceInstance {
5052        #[inline(always)]
5053        fn new_empty() -> Self {
5054            Self::default()
5055        }
5056
5057        unsafe fn decode(
5058            &mut self,
5059            decoder: &mut fidl::encoding::Decoder<'_, D>,
5060            offset: usize,
5061            mut depth: fidl::encoding::Depth,
5062        ) -> fidl::Result<()> {
5063            decoder.debug_check_bounds::<Self>(offset);
5064            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5065                None => return Err(fidl::Error::NotNullable),
5066                Some(len) => len,
5067            };
5068            // Calling decoder.out_of_line_offset(0) is not allowed.
5069            if len == 0 {
5070                return Ok(());
5071            };
5072            depth.increment()?;
5073            let envelope_size = 8;
5074            let bytes_len = len * envelope_size;
5075            let offset = decoder.out_of_line_offset(bytes_len)?;
5076            // Decode the envelope for each type.
5077            let mut _next_ordinal_to_read = 0;
5078            let mut next_offset = offset;
5079            let end_offset = offset + bytes_len;
5080            _next_ordinal_to_read += 1;
5081            if next_offset >= end_offset {
5082                return Ok(());
5083            }
5084
5085            // Decode unknown envelopes for gaps in ordinals.
5086            while _next_ordinal_to_read < 1 {
5087                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5088                _next_ordinal_to_read += 1;
5089                next_offset += envelope_size;
5090            }
5091
5092            let next_out_of_line = decoder.next_out_of_line();
5093            let handles_before = decoder.remaining_handles();
5094            if let Some((inlined, num_bytes, num_handles)) =
5095                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5096            {
5097                let member_inline_size =
5098                    <fidl::encoding::BoundedString<22> as fidl::encoding::TypeMarker>::inline_size(
5099                        decoder.context,
5100                    );
5101                if inlined != (member_inline_size <= 4) {
5102                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5103                }
5104                let inner_offset;
5105                let mut inner_depth = depth.clone();
5106                if inlined {
5107                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5108                    inner_offset = next_offset;
5109                } else {
5110                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5111                    inner_depth.increment()?;
5112                }
5113                let val_ref = self
5114                    .service
5115                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<22>, D));
5116                fidl::decode!(
5117                    fidl::encoding::BoundedString<22>,
5118                    D,
5119                    val_ref,
5120                    decoder,
5121                    inner_offset,
5122                    inner_depth
5123                )?;
5124                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5125                {
5126                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5127                }
5128                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5129                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5130                }
5131            }
5132
5133            next_offset += envelope_size;
5134            _next_ordinal_to_read += 1;
5135            if next_offset >= end_offset {
5136                return Ok(());
5137            }
5138
5139            // Decode unknown envelopes for gaps in ordinals.
5140            while _next_ordinal_to_read < 2 {
5141                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5142                _next_ordinal_to_read += 1;
5143                next_offset += envelope_size;
5144            }
5145
5146            let next_out_of_line = decoder.next_out_of_line();
5147            let handles_before = decoder.remaining_handles();
5148            if let Some((inlined, num_bytes, num_handles)) =
5149                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5150            {
5151                let member_inline_size =
5152                    <fidl::encoding::BoundedString<63> as fidl::encoding::TypeMarker>::inline_size(
5153                        decoder.context,
5154                    );
5155                if inlined != (member_inline_size <= 4) {
5156                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5157                }
5158                let inner_offset;
5159                let mut inner_depth = depth.clone();
5160                if inlined {
5161                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5162                    inner_offset = next_offset;
5163                } else {
5164                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5165                    inner_depth.increment()?;
5166                }
5167                let val_ref = self
5168                    .instance
5169                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<63>, D));
5170                fidl::decode!(
5171                    fidl::encoding::BoundedString<63>,
5172                    D,
5173                    val_ref,
5174                    decoder,
5175                    inner_offset,
5176                    inner_depth
5177                )?;
5178                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5179                {
5180                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5181                }
5182                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5183                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5184                }
5185            }
5186
5187            next_offset += envelope_size;
5188            _next_ordinal_to_read += 1;
5189            if next_offset >= end_offset {
5190                return Ok(());
5191            }
5192
5193            // Decode unknown envelopes for gaps in ordinals.
5194            while _next_ordinal_to_read < 3 {
5195                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5196                _next_ordinal_to_read += 1;
5197                next_offset += envelope_size;
5198            }
5199
5200            let next_out_of_line = decoder.next_out_of_line();
5201            let handles_before = decoder.remaining_handles();
5202            if let Some((inlined, num_bytes, num_handles)) =
5203                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5204            {
5205                let member_inline_size = <fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5206                if inlined != (member_inline_size <= 4) {
5207                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5208                }
5209                let inner_offset;
5210                let mut inner_depth = depth.clone();
5211                if inlined {
5212                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5213                    inner_offset = next_offset;
5214                } else {
5215                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5216                    inner_depth.increment()?;
5217                }
5218                let val_ref = self.ipv4_endpoint.get_or_insert_with(|| {
5219                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv4SocketAddress, D)
5220                });
5221                fidl::decode!(
5222                    fidl_fuchsia_net__common::Ipv4SocketAddress,
5223                    D,
5224                    val_ref,
5225                    decoder,
5226                    inner_offset,
5227                    inner_depth
5228                )?;
5229                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5230                {
5231                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5232                }
5233                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5234                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5235                }
5236            }
5237
5238            next_offset += envelope_size;
5239            _next_ordinal_to_read += 1;
5240            if next_offset >= end_offset {
5241                return Ok(());
5242            }
5243
5244            // Decode unknown envelopes for gaps in ordinals.
5245            while _next_ordinal_to_read < 4 {
5246                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5247                _next_ordinal_to_read += 1;
5248                next_offset += envelope_size;
5249            }
5250
5251            let next_out_of_line = decoder.next_out_of_line();
5252            let handles_before = decoder.remaining_handles();
5253            if let Some((inlined, num_bytes, num_handles)) =
5254                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5255            {
5256                let member_inline_size = <fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5257                if inlined != (member_inline_size <= 4) {
5258                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5259                }
5260                let inner_offset;
5261                let mut inner_depth = depth.clone();
5262                if inlined {
5263                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5264                    inner_offset = next_offset;
5265                } else {
5266                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5267                    inner_depth.increment()?;
5268                }
5269                let val_ref = self.ipv6_endpoint.get_or_insert_with(|| {
5270                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6SocketAddress, D)
5271                });
5272                fidl::decode!(
5273                    fidl_fuchsia_net__common::Ipv6SocketAddress,
5274                    D,
5275                    val_ref,
5276                    decoder,
5277                    inner_offset,
5278                    inner_depth
5279                )?;
5280                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5281                {
5282                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5283                }
5284                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5285                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5286                }
5287            }
5288
5289            next_offset += envelope_size;
5290            _next_ordinal_to_read += 1;
5291            if next_offset >= end_offset {
5292                return Ok(());
5293            }
5294
5295            // Decode unknown envelopes for gaps in ordinals.
5296            while _next_ordinal_to_read < 5 {
5297                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5298                _next_ordinal_to_read += 1;
5299                next_offset += envelope_size;
5300            }
5301
5302            let next_out_of_line = decoder.next_out_of_line();
5303            let handles_before = decoder.remaining_handles();
5304            if let Some((inlined, num_bytes, num_handles)) =
5305                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5306            {
5307                let member_inline_size = <fidl::encoding::Vector<
5308                    fidl::encoding::BoundedString<255>,
5309                    256,
5310                > as fidl::encoding::TypeMarker>::inline_size(
5311                    decoder.context
5312                );
5313                if inlined != (member_inline_size <= 4) {
5314                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5315                }
5316                let inner_offset;
5317                let mut inner_depth = depth.clone();
5318                if inlined {
5319                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5320                    inner_offset = next_offset;
5321                } else {
5322                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5323                    inner_depth.increment()?;
5324                }
5325                let val_ref = self.text.get_or_insert_with(|| {
5326                    fidl::new_empty!(
5327                        fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5328                        D
5329                    )
5330                });
5331                fidl::decode!(
5332                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5333                    D,
5334                    val_ref,
5335                    decoder,
5336                    inner_offset,
5337                    inner_depth
5338                )?;
5339                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5340                {
5341                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5342                }
5343                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5344                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5345                }
5346            }
5347
5348            next_offset += envelope_size;
5349            _next_ordinal_to_read += 1;
5350            if next_offset >= end_offset {
5351                return Ok(());
5352            }
5353
5354            // Decode unknown envelopes for gaps in ordinals.
5355            while _next_ordinal_to_read < 6 {
5356                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5357                _next_ordinal_to_read += 1;
5358                next_offset += envelope_size;
5359            }
5360
5361            let next_out_of_line = decoder.next_out_of_line();
5362            let handles_before = decoder.remaining_handles();
5363            if let Some((inlined, num_bytes, num_handles)) =
5364                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5365            {
5366                let member_inline_size =
5367                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5368                if inlined != (member_inline_size <= 4) {
5369                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5370                }
5371                let inner_offset;
5372                let mut inner_depth = depth.clone();
5373                if inlined {
5374                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5375                    inner_offset = next_offset;
5376                } else {
5377                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5378                    inner_depth.increment()?;
5379                }
5380                let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
5381                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5382                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5383                {
5384                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5385                }
5386                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5387                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5388                }
5389            }
5390
5391            next_offset += envelope_size;
5392            _next_ordinal_to_read += 1;
5393            if next_offset >= end_offset {
5394                return Ok(());
5395            }
5396
5397            // Decode unknown envelopes for gaps in ordinals.
5398            while _next_ordinal_to_read < 7 {
5399                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5400                _next_ordinal_to_read += 1;
5401                next_offset += envelope_size;
5402            }
5403
5404            let next_out_of_line = decoder.next_out_of_line();
5405            let handles_before = decoder.remaining_handles();
5406            if let Some((inlined, num_bytes, num_handles)) =
5407                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5408            {
5409                let member_inline_size =
5410                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5411                if inlined != (member_inline_size <= 4) {
5412                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5413                }
5414                let inner_offset;
5415                let mut inner_depth = depth.clone();
5416                if inlined {
5417                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5418                    inner_offset = next_offset;
5419                } else {
5420                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5421                    inner_depth.increment()?;
5422                }
5423                let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
5424                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5425                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5426                {
5427                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5428                }
5429                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5430                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5431                }
5432            }
5433
5434            next_offset += envelope_size;
5435            _next_ordinal_to_read += 1;
5436            if next_offset >= end_offset {
5437                return Ok(());
5438            }
5439
5440            // Decode unknown envelopes for gaps in ordinals.
5441            while _next_ordinal_to_read < 8 {
5442                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5443                _next_ordinal_to_read += 1;
5444                next_offset += envelope_size;
5445            }
5446
5447            let next_out_of_line = decoder.next_out_of_line();
5448            let handles_before = decoder.remaining_handles();
5449            if let Some((inlined, num_bytes, num_handles)) =
5450                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5451            {
5452                let member_inline_size =
5453                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5454                        decoder.context,
5455                    );
5456                if inlined != (member_inline_size <= 4) {
5457                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5458                }
5459                let inner_offset;
5460                let mut inner_depth = depth.clone();
5461                if inlined {
5462                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5463                    inner_offset = next_offset;
5464                } else {
5465                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5466                    inner_depth.increment()?;
5467                }
5468                let val_ref = self
5469                    .target
5470                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5471                fidl::decode!(
5472                    fidl::encoding::BoundedString<255>,
5473                    D,
5474                    val_ref,
5475                    decoder,
5476                    inner_offset,
5477                    inner_depth
5478                )?;
5479                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5480                {
5481                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5482                }
5483                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5484                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5485                }
5486            }
5487
5488            next_offset += envelope_size;
5489            _next_ordinal_to_read += 1;
5490            if next_offset >= end_offset {
5491                return Ok(());
5492            }
5493
5494            // Decode unknown envelopes for gaps in ordinals.
5495            while _next_ordinal_to_read < 9 {
5496                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5497                _next_ordinal_to_read += 1;
5498                next_offset += envelope_size;
5499            }
5500
5501            let next_out_of_line = decoder.next_out_of_line();
5502            let handles_before = decoder.remaining_handles();
5503            if let Some((inlined, num_bytes, num_handles)) =
5504                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5505            {
5506                let member_inline_size = <fidl::encoding::Vector<
5507                    fidl_fuchsia_net__common::SocketAddress,
5508                    64,
5509                > as fidl::encoding::TypeMarker>::inline_size(
5510                    decoder.context
5511                );
5512                if inlined != (member_inline_size <= 4) {
5513                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5514                }
5515                let inner_offset;
5516                let mut inner_depth = depth.clone();
5517                if inlined {
5518                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5519                    inner_offset = next_offset;
5520                } else {
5521                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5522                    inner_depth.increment()?;
5523                }
5524                let val_ref =
5525                self.addresses.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D));
5526                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5527                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5528                {
5529                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5530                }
5531                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5532                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5533                }
5534            }
5535
5536            next_offset += envelope_size;
5537            _next_ordinal_to_read += 1;
5538            if next_offset >= end_offset {
5539                return Ok(());
5540            }
5541
5542            // Decode unknown envelopes for gaps in ordinals.
5543            while _next_ordinal_to_read < 10 {
5544                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5545                _next_ordinal_to_read += 1;
5546                next_offset += envelope_size;
5547            }
5548
5549            let next_out_of_line = decoder.next_out_of_line();
5550            let handles_before = decoder.remaining_handles();
5551            if let Some((inlined, num_bytes, num_handles)) =
5552                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5553            {
5554                let member_inline_size = <fidl::encoding::Vector<
5555                    fidl::encoding::Vector<u8, 255>,
5556                    256,
5557                > as fidl::encoding::TypeMarker>::inline_size(
5558                    decoder.context
5559                );
5560                if inlined != (member_inline_size <= 4) {
5561                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5562                }
5563                let inner_offset;
5564                let mut inner_depth = depth.clone();
5565                if inlined {
5566                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5567                    inner_offset = next_offset;
5568                } else {
5569                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5570                    inner_depth.increment()?;
5571                }
5572                let val_ref = self.text_strings.get_or_insert_with(|| {
5573                    fidl::new_empty!(
5574                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5575                        D
5576                    )
5577                });
5578                fidl::decode!(
5579                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5580                    D,
5581                    val_ref,
5582                    decoder,
5583                    inner_offset,
5584                    inner_depth
5585                )?;
5586                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5587                {
5588                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5589                }
5590                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5591                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5592                }
5593            }
5594
5595            next_offset += envelope_size;
5596
5597            // Decode the remaining unknown envelopes.
5598            while next_offset < end_offset {
5599                _next_ordinal_to_read += 1;
5600                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5601                next_offset += envelope_size;
5602            }
5603
5604            Ok(())
5605        }
5606    }
5607
5608    impl ServiceInstancePublication {
5609        #[inline(always)]
5610        fn max_ordinal_present(&self) -> u64 {
5611            if let Some(_) = self.txt_ttl {
5612                return 7;
5613            }
5614            if let Some(_) = self.srv_ttl {
5615                return 6;
5616            }
5617            if let Some(_) = self.ptr_ttl {
5618                return 5;
5619            }
5620            if let Some(_) = self.srv_weight {
5621                return 4;
5622            }
5623            if let Some(_) = self.srv_priority {
5624                return 3;
5625            }
5626            if let Some(_) = self.text {
5627                return 2;
5628            }
5629            if let Some(_) = self.port {
5630                return 1;
5631            }
5632            0
5633        }
5634    }
5635
5636    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublication {
5637        type Borrowed<'a> = &'a Self;
5638        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5639            value
5640        }
5641    }
5642
5643    unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublication {
5644        type Owned = Self;
5645
5646        #[inline(always)]
5647        fn inline_align(_context: fidl::encoding::Context) -> usize {
5648            8
5649        }
5650
5651        #[inline(always)]
5652        fn inline_size(_context: fidl::encoding::Context) -> usize {
5653            16
5654        }
5655    }
5656
5657    unsafe impl<D: fidl::encoding::ResourceDialect>
5658        fidl::encoding::Encode<ServiceInstancePublication, D> for &ServiceInstancePublication
5659    {
5660        unsafe fn encode(
5661            self,
5662            encoder: &mut fidl::encoding::Encoder<'_, D>,
5663            offset: usize,
5664            mut depth: fidl::encoding::Depth,
5665        ) -> fidl::Result<()> {
5666            encoder.debug_check_bounds::<ServiceInstancePublication>(offset);
5667            // Vector header
5668            let max_ordinal: u64 = self.max_ordinal_present();
5669            encoder.write_num(max_ordinal, offset);
5670            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5671            // Calling encoder.out_of_line_offset(0) is not allowed.
5672            if max_ordinal == 0 {
5673                return Ok(());
5674            }
5675            depth.increment()?;
5676            let envelope_size = 8;
5677            let bytes_len = max_ordinal as usize * envelope_size;
5678            #[allow(unused_variables)]
5679            let offset = encoder.out_of_line_offset(bytes_len);
5680            let mut _prev_end_offset: usize = 0;
5681            if 1 > max_ordinal {
5682                return Ok(());
5683            }
5684
5685            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5686            // are envelope_size bytes.
5687            let cur_offset: usize = (1 - 1) * envelope_size;
5688
5689            // Zero reserved fields.
5690            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5691
5692            // Safety:
5693            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5694            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5695            //   envelope_size bytes, there is always sufficient room.
5696            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5697                self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5698                encoder,
5699                offset + cur_offset,
5700                depth,
5701            )?;
5702
5703            _prev_end_offset = cur_offset + envelope_size;
5704            if 2 > max_ordinal {
5705                return Ok(());
5706            }
5707
5708            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5709            // are envelope_size bytes.
5710            let cur_offset: usize = (2 - 1) * envelope_size;
5711
5712            // Zero reserved fields.
5713            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5714
5715            // Safety:
5716            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5717            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5718            //   envelope_size bytes, there is always sufficient room.
5719            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5720            self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5721            encoder, offset + cur_offset, depth
5722        )?;
5723
5724            _prev_end_offset = cur_offset + envelope_size;
5725            if 3 > max_ordinal {
5726                return Ok(());
5727            }
5728
5729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5730            // are envelope_size bytes.
5731            let cur_offset: usize = (3 - 1) * envelope_size;
5732
5733            // Zero reserved fields.
5734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5735
5736            // Safety:
5737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5739            //   envelope_size bytes, there is always sufficient room.
5740            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5741                self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5742                encoder,
5743                offset + cur_offset,
5744                depth,
5745            )?;
5746
5747            _prev_end_offset = cur_offset + envelope_size;
5748            if 4 > max_ordinal {
5749                return Ok(());
5750            }
5751
5752            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5753            // are envelope_size bytes.
5754            let cur_offset: usize = (4 - 1) * envelope_size;
5755
5756            // Zero reserved fields.
5757            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5758
5759            // Safety:
5760            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5761            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5762            //   envelope_size bytes, there is always sufficient room.
5763            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5764                self.srv_weight.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5765                encoder,
5766                offset + cur_offset,
5767                depth,
5768            )?;
5769
5770            _prev_end_offset = cur_offset + envelope_size;
5771            if 5 > max_ordinal {
5772                return Ok(());
5773            }
5774
5775            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5776            // are envelope_size bytes.
5777            let cur_offset: usize = (5 - 1) * envelope_size;
5778
5779            // Zero reserved fields.
5780            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5781
5782            // Safety:
5783            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5784            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5785            //   envelope_size bytes, there is always sufficient room.
5786            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5787                self.ptr_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5788                encoder,
5789                offset + cur_offset,
5790                depth,
5791            )?;
5792
5793            _prev_end_offset = cur_offset + envelope_size;
5794            if 6 > max_ordinal {
5795                return Ok(());
5796            }
5797
5798            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5799            // are envelope_size bytes.
5800            let cur_offset: usize = (6 - 1) * envelope_size;
5801
5802            // Zero reserved fields.
5803            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5804
5805            // Safety:
5806            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5807            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5808            //   envelope_size bytes, there is always sufficient room.
5809            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5810                self.srv_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5811                encoder,
5812                offset + cur_offset,
5813                depth,
5814            )?;
5815
5816            _prev_end_offset = cur_offset + envelope_size;
5817            if 7 > max_ordinal {
5818                return Ok(());
5819            }
5820
5821            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5822            // are envelope_size bytes.
5823            let cur_offset: usize = (7 - 1) * envelope_size;
5824
5825            // Zero reserved fields.
5826            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5827
5828            // Safety:
5829            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5830            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5831            //   envelope_size bytes, there is always sufficient room.
5832            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5833                self.txt_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5834                encoder,
5835                offset + cur_offset,
5836                depth,
5837            )?;
5838
5839            _prev_end_offset = cur_offset + envelope_size;
5840
5841            Ok(())
5842        }
5843    }
5844
5845    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5846        for ServiceInstancePublication
5847    {
5848        #[inline(always)]
5849        fn new_empty() -> Self {
5850            Self::default()
5851        }
5852
5853        unsafe fn decode(
5854            &mut self,
5855            decoder: &mut fidl::encoding::Decoder<'_, D>,
5856            offset: usize,
5857            mut depth: fidl::encoding::Depth,
5858        ) -> fidl::Result<()> {
5859            decoder.debug_check_bounds::<Self>(offset);
5860            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5861                None => return Err(fidl::Error::NotNullable),
5862                Some(len) => len,
5863            };
5864            // Calling decoder.out_of_line_offset(0) is not allowed.
5865            if len == 0 {
5866                return Ok(());
5867            };
5868            depth.increment()?;
5869            let envelope_size = 8;
5870            let bytes_len = len * envelope_size;
5871            let offset = decoder.out_of_line_offset(bytes_len)?;
5872            // Decode the envelope for each type.
5873            let mut _next_ordinal_to_read = 0;
5874            let mut next_offset = offset;
5875            let end_offset = offset + bytes_len;
5876            _next_ordinal_to_read += 1;
5877            if next_offset >= end_offset {
5878                return Ok(());
5879            }
5880
5881            // Decode unknown envelopes for gaps in ordinals.
5882            while _next_ordinal_to_read < 1 {
5883                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5884                _next_ordinal_to_read += 1;
5885                next_offset += envelope_size;
5886            }
5887
5888            let next_out_of_line = decoder.next_out_of_line();
5889            let handles_before = decoder.remaining_handles();
5890            if let Some((inlined, num_bytes, num_handles)) =
5891                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5892            {
5893                let member_inline_size =
5894                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5895                if inlined != (member_inline_size <= 4) {
5896                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5897                }
5898                let inner_offset;
5899                let mut inner_depth = depth.clone();
5900                if inlined {
5901                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5902                    inner_offset = next_offset;
5903                } else {
5904                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5905                    inner_depth.increment()?;
5906                }
5907                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
5908                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5909                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5910                {
5911                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5912                }
5913                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5914                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5915                }
5916            }
5917
5918            next_offset += envelope_size;
5919            _next_ordinal_to_read += 1;
5920            if next_offset >= end_offset {
5921                return Ok(());
5922            }
5923
5924            // Decode unknown envelopes for gaps in ordinals.
5925            while _next_ordinal_to_read < 2 {
5926                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5927                _next_ordinal_to_read += 1;
5928                next_offset += envelope_size;
5929            }
5930
5931            let next_out_of_line = decoder.next_out_of_line();
5932            let handles_before = decoder.remaining_handles();
5933            if let Some((inlined, num_bytes, num_handles)) =
5934                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5935            {
5936                let member_inline_size = <fidl::encoding::Vector<
5937                    fidl::encoding::Vector<u8, 255>,
5938                    256,
5939                > as fidl::encoding::TypeMarker>::inline_size(
5940                    decoder.context
5941                );
5942                if inlined != (member_inline_size <= 4) {
5943                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5944                }
5945                let inner_offset;
5946                let mut inner_depth = depth.clone();
5947                if inlined {
5948                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5949                    inner_offset = next_offset;
5950                } else {
5951                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5952                    inner_depth.increment()?;
5953                }
5954                let val_ref = self.text.get_or_insert_with(|| {
5955                    fidl::new_empty!(
5956                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5957                        D
5958                    )
5959                });
5960                fidl::decode!(
5961                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5962                    D,
5963                    val_ref,
5964                    decoder,
5965                    inner_offset,
5966                    inner_depth
5967                )?;
5968                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5969                {
5970                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5971                }
5972                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5973                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5974                }
5975            }
5976
5977            next_offset += envelope_size;
5978            _next_ordinal_to_read += 1;
5979            if next_offset >= end_offset {
5980                return Ok(());
5981            }
5982
5983            // Decode unknown envelopes for gaps in ordinals.
5984            while _next_ordinal_to_read < 3 {
5985                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5986                _next_ordinal_to_read += 1;
5987                next_offset += envelope_size;
5988            }
5989
5990            let next_out_of_line = decoder.next_out_of_line();
5991            let handles_before = decoder.remaining_handles();
5992            if let Some((inlined, num_bytes, num_handles)) =
5993                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5994            {
5995                let member_inline_size =
5996                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5997                if inlined != (member_inline_size <= 4) {
5998                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5999                }
6000                let inner_offset;
6001                let mut inner_depth = depth.clone();
6002                if inlined {
6003                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6004                    inner_offset = next_offset;
6005                } else {
6006                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6007                    inner_depth.increment()?;
6008                }
6009                let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
6010                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6012                {
6013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6014                }
6015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6017                }
6018            }
6019
6020            next_offset += envelope_size;
6021            _next_ordinal_to_read += 1;
6022            if next_offset >= end_offset {
6023                return Ok(());
6024            }
6025
6026            // Decode unknown envelopes for gaps in ordinals.
6027            while _next_ordinal_to_read < 4 {
6028                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6029                _next_ordinal_to_read += 1;
6030                next_offset += envelope_size;
6031            }
6032
6033            let next_out_of_line = decoder.next_out_of_line();
6034            let handles_before = decoder.remaining_handles();
6035            if let Some((inlined, num_bytes, num_handles)) =
6036                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6037            {
6038                let member_inline_size =
6039                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6040                if inlined != (member_inline_size <= 4) {
6041                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6042                }
6043                let inner_offset;
6044                let mut inner_depth = depth.clone();
6045                if inlined {
6046                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6047                    inner_offset = next_offset;
6048                } else {
6049                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6050                    inner_depth.increment()?;
6051                }
6052                let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
6053                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6054                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6055                {
6056                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6057                }
6058                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6059                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6060                }
6061            }
6062
6063            next_offset += envelope_size;
6064            _next_ordinal_to_read += 1;
6065            if next_offset >= end_offset {
6066                return Ok(());
6067            }
6068
6069            // Decode unknown envelopes for gaps in ordinals.
6070            while _next_ordinal_to_read < 5 {
6071                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6072                _next_ordinal_to_read += 1;
6073                next_offset += envelope_size;
6074            }
6075
6076            let next_out_of_line = decoder.next_out_of_line();
6077            let handles_before = decoder.remaining_handles();
6078            if let Some((inlined, num_bytes, num_handles)) =
6079                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6080            {
6081                let member_inline_size =
6082                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6083                if inlined != (member_inline_size <= 4) {
6084                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6085                }
6086                let inner_offset;
6087                let mut inner_depth = depth.clone();
6088                if inlined {
6089                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6090                    inner_offset = next_offset;
6091                } else {
6092                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6093                    inner_depth.increment()?;
6094                }
6095                let val_ref = self.ptr_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6096                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6097                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6098                {
6099                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6100                }
6101                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6102                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6103                }
6104            }
6105
6106            next_offset += envelope_size;
6107            _next_ordinal_to_read += 1;
6108            if next_offset >= end_offset {
6109                return Ok(());
6110            }
6111
6112            // Decode unknown envelopes for gaps in ordinals.
6113            while _next_ordinal_to_read < 6 {
6114                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6115                _next_ordinal_to_read += 1;
6116                next_offset += envelope_size;
6117            }
6118
6119            let next_out_of_line = decoder.next_out_of_line();
6120            let handles_before = decoder.remaining_handles();
6121            if let Some((inlined, num_bytes, num_handles)) =
6122                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6123            {
6124                let member_inline_size =
6125                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6126                if inlined != (member_inline_size <= 4) {
6127                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6128                }
6129                let inner_offset;
6130                let mut inner_depth = depth.clone();
6131                if inlined {
6132                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6133                    inner_offset = next_offset;
6134                } else {
6135                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6136                    inner_depth.increment()?;
6137                }
6138                let val_ref = self.srv_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6139                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6140                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6141                {
6142                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6143                }
6144                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6145                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6146                }
6147            }
6148
6149            next_offset += envelope_size;
6150            _next_ordinal_to_read += 1;
6151            if next_offset >= end_offset {
6152                return Ok(());
6153            }
6154
6155            // Decode unknown envelopes for gaps in ordinals.
6156            while _next_ordinal_to_read < 7 {
6157                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6158                _next_ordinal_to_read += 1;
6159                next_offset += envelope_size;
6160            }
6161
6162            let next_out_of_line = decoder.next_out_of_line();
6163            let handles_before = decoder.remaining_handles();
6164            if let Some((inlined, num_bytes, num_handles)) =
6165                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6166            {
6167                let member_inline_size =
6168                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6169                if inlined != (member_inline_size <= 4) {
6170                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6171                }
6172                let inner_offset;
6173                let mut inner_depth = depth.clone();
6174                if inlined {
6175                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6176                    inner_offset = next_offset;
6177                } else {
6178                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6179                    inner_depth.increment()?;
6180                }
6181                let val_ref = self.txt_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6182                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6183                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6184                {
6185                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6186                }
6187                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6188                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6189                }
6190            }
6191
6192            next_offset += envelope_size;
6193
6194            // Decode the remaining unknown envelopes.
6195            while next_offset < end_offset {
6196                _next_ordinal_to_read += 1;
6197                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6198                next_offset += envelope_size;
6199            }
6200
6201            Ok(())
6202        }
6203    }
6204
6205    impl ServiceInstancePublicationOptions {
6206        #[inline(always)]
6207        fn max_ordinal_present(&self) -> u64 {
6208            if let Some(_) = self.perform_probe {
6209                return 3;
6210            }
6211            if let Some(_) = self.ip_versions {
6212                return 2;
6213            }
6214            if let Some(_) = self.media {
6215                return 1;
6216            }
6217            0
6218        }
6219    }
6220
6221    impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationOptions {
6222        type Borrowed<'a> = &'a Self;
6223        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6224            value
6225        }
6226    }
6227
6228    unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationOptions {
6229        type Owned = Self;
6230
6231        #[inline(always)]
6232        fn inline_align(_context: fidl::encoding::Context) -> usize {
6233            8
6234        }
6235
6236        #[inline(always)]
6237        fn inline_size(_context: fidl::encoding::Context) -> usize {
6238            16
6239        }
6240    }
6241
6242    unsafe impl<D: fidl::encoding::ResourceDialect>
6243        fidl::encoding::Encode<ServiceInstancePublicationOptions, D>
6244        for &ServiceInstancePublicationOptions
6245    {
6246        unsafe fn encode(
6247            self,
6248            encoder: &mut fidl::encoding::Encoder<'_, D>,
6249            offset: usize,
6250            mut depth: fidl::encoding::Depth,
6251        ) -> fidl::Result<()> {
6252            encoder.debug_check_bounds::<ServiceInstancePublicationOptions>(offset);
6253            // Vector header
6254            let max_ordinal: u64 = self.max_ordinal_present();
6255            encoder.write_num(max_ordinal, offset);
6256            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6257            // Calling encoder.out_of_line_offset(0) is not allowed.
6258            if max_ordinal == 0 {
6259                return Ok(());
6260            }
6261            depth.increment()?;
6262            let envelope_size = 8;
6263            let bytes_len = max_ordinal as usize * envelope_size;
6264            #[allow(unused_variables)]
6265            let offset = encoder.out_of_line_offset(bytes_len);
6266            let mut _prev_end_offset: usize = 0;
6267            if 1 > max_ordinal {
6268                return Ok(());
6269            }
6270
6271            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6272            // are envelope_size bytes.
6273            let cur_offset: usize = (1 - 1) * envelope_size;
6274
6275            // Zero reserved fields.
6276            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6277
6278            // Safety:
6279            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6280            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6281            //   envelope_size bytes, there is always sufficient room.
6282            fidl::encoding::encode_in_envelope_optional::<Media, D>(
6283                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6284                encoder,
6285                offset + cur_offset,
6286                depth,
6287            )?;
6288
6289            _prev_end_offset = cur_offset + envelope_size;
6290            if 2 > max_ordinal {
6291                return Ok(());
6292            }
6293
6294            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6295            // are envelope_size bytes.
6296            let cur_offset: usize = (2 - 1) * envelope_size;
6297
6298            // Zero reserved fields.
6299            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6300
6301            // Safety:
6302            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6303            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6304            //   envelope_size bytes, there is always sufficient room.
6305            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6306                self.ip_versions
6307                    .as_ref()
6308                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6309                encoder,
6310                offset + cur_offset,
6311                depth,
6312            )?;
6313
6314            _prev_end_offset = cur_offset + envelope_size;
6315            if 3 > max_ordinal {
6316                return Ok(());
6317            }
6318
6319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6320            // are envelope_size bytes.
6321            let cur_offset: usize = (3 - 1) * envelope_size;
6322
6323            // Zero reserved fields.
6324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6325
6326            // Safety:
6327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6329            //   envelope_size bytes, there is always sufficient room.
6330            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6331                self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6332                encoder,
6333                offset + cur_offset,
6334                depth,
6335            )?;
6336
6337            _prev_end_offset = cur_offset + envelope_size;
6338
6339            Ok(())
6340        }
6341    }
6342
6343    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6344        for ServiceInstancePublicationOptions
6345    {
6346        #[inline(always)]
6347        fn new_empty() -> Self {
6348            Self::default()
6349        }
6350
6351        unsafe fn decode(
6352            &mut self,
6353            decoder: &mut fidl::encoding::Decoder<'_, D>,
6354            offset: usize,
6355            mut depth: fidl::encoding::Depth,
6356        ) -> fidl::Result<()> {
6357            decoder.debug_check_bounds::<Self>(offset);
6358            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6359                None => return Err(fidl::Error::NotNullable),
6360                Some(len) => len,
6361            };
6362            // Calling decoder.out_of_line_offset(0) is not allowed.
6363            if len == 0 {
6364                return Ok(());
6365            };
6366            depth.increment()?;
6367            let envelope_size = 8;
6368            let bytes_len = len * envelope_size;
6369            let offset = decoder.out_of_line_offset(bytes_len)?;
6370            // Decode the envelope for each type.
6371            let mut _next_ordinal_to_read = 0;
6372            let mut next_offset = offset;
6373            let end_offset = offset + bytes_len;
6374            _next_ordinal_to_read += 1;
6375            if next_offset >= end_offset {
6376                return Ok(());
6377            }
6378
6379            // Decode unknown envelopes for gaps in ordinals.
6380            while _next_ordinal_to_read < 1 {
6381                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6382                _next_ordinal_to_read += 1;
6383                next_offset += envelope_size;
6384            }
6385
6386            let next_out_of_line = decoder.next_out_of_line();
6387            let handles_before = decoder.remaining_handles();
6388            if let Some((inlined, num_bytes, num_handles)) =
6389                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6390            {
6391                let member_inline_size =
6392                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6393                if inlined != (member_inline_size <= 4) {
6394                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6395                }
6396                let inner_offset;
6397                let mut inner_depth = depth.clone();
6398                if inlined {
6399                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6400                    inner_offset = next_offset;
6401                } else {
6402                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6403                    inner_depth.increment()?;
6404                }
6405                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6406                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6407                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6408                {
6409                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6410                }
6411                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6412                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6413                }
6414            }
6415
6416            next_offset += envelope_size;
6417            _next_ordinal_to_read += 1;
6418            if next_offset >= end_offset {
6419                return Ok(());
6420            }
6421
6422            // Decode unknown envelopes for gaps in ordinals.
6423            while _next_ordinal_to_read < 2 {
6424                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6425                _next_ordinal_to_read += 1;
6426                next_offset += envelope_size;
6427            }
6428
6429            let next_out_of_line = decoder.next_out_of_line();
6430            let handles_before = decoder.remaining_handles();
6431            if let Some((inlined, num_bytes, num_handles)) =
6432                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6433            {
6434                let member_inline_size =
6435                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6436                if inlined != (member_inline_size <= 4) {
6437                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6438                }
6439                let inner_offset;
6440                let mut inner_depth = depth.clone();
6441                if inlined {
6442                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6443                    inner_offset = next_offset;
6444                } else {
6445                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6446                    inner_depth.increment()?;
6447                }
6448                let val_ref =
6449                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6450                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6451                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6452                {
6453                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6454                }
6455                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6456                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6457                }
6458            }
6459
6460            next_offset += envelope_size;
6461            _next_ordinal_to_read += 1;
6462            if next_offset >= end_offset {
6463                return Ok(());
6464            }
6465
6466            // Decode unknown envelopes for gaps in ordinals.
6467            while _next_ordinal_to_read < 3 {
6468                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6469                _next_ordinal_to_read += 1;
6470                next_offset += envelope_size;
6471            }
6472
6473            let next_out_of_line = decoder.next_out_of_line();
6474            let handles_before = decoder.remaining_handles();
6475            if let Some((inlined, num_bytes, num_handles)) =
6476                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6477            {
6478                let member_inline_size =
6479                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6480                if inlined != (member_inline_size <= 4) {
6481                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6482                }
6483                let inner_offset;
6484                let mut inner_depth = depth.clone();
6485                if inlined {
6486                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6487                    inner_offset = next_offset;
6488                } else {
6489                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6490                    inner_depth.increment()?;
6491                }
6492                let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
6493                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6494                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6495                {
6496                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6497                }
6498                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6499                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6500                }
6501            }
6502
6503            next_offset += envelope_size;
6504
6505            // Decode the remaining unknown envelopes.
6506            while next_offset < end_offset {
6507                _next_ordinal_to_read += 1;
6508                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6509                next_offset += envelope_size;
6510            }
6511
6512            Ok(())
6513        }
6514    }
6515
6516    impl ServiceInstanceResolutionOptions {
6517        #[inline(always)]
6518        fn max_ordinal_present(&self) -> u64 {
6519            if let Some(_) = self.exclude_local_proxies {
6520                return 4;
6521            }
6522            if let Some(_) = self.exclude_local {
6523                return 3;
6524            }
6525            if let Some(_) = self.ip_versions {
6526                return 2;
6527            }
6528            if let Some(_) = self.media {
6529                return 1;
6530            }
6531            0
6532        }
6533    }
6534
6535    impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolutionOptions {
6536        type Borrowed<'a> = &'a Self;
6537        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6538            value
6539        }
6540    }
6541
6542    unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolutionOptions {
6543        type Owned = Self;
6544
6545        #[inline(always)]
6546        fn inline_align(_context: fidl::encoding::Context) -> usize {
6547            8
6548        }
6549
6550        #[inline(always)]
6551        fn inline_size(_context: fidl::encoding::Context) -> usize {
6552            16
6553        }
6554    }
6555
6556    unsafe impl<D: fidl::encoding::ResourceDialect>
6557        fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>
6558        for &ServiceInstanceResolutionOptions
6559    {
6560        unsafe fn encode(
6561            self,
6562            encoder: &mut fidl::encoding::Encoder<'_, D>,
6563            offset: usize,
6564            mut depth: fidl::encoding::Depth,
6565        ) -> fidl::Result<()> {
6566            encoder.debug_check_bounds::<ServiceInstanceResolutionOptions>(offset);
6567            // Vector header
6568            let max_ordinal: u64 = self.max_ordinal_present();
6569            encoder.write_num(max_ordinal, offset);
6570            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6571            // Calling encoder.out_of_line_offset(0) is not allowed.
6572            if max_ordinal == 0 {
6573                return Ok(());
6574            }
6575            depth.increment()?;
6576            let envelope_size = 8;
6577            let bytes_len = max_ordinal as usize * envelope_size;
6578            #[allow(unused_variables)]
6579            let offset = encoder.out_of_line_offset(bytes_len);
6580            let mut _prev_end_offset: usize = 0;
6581            if 1 > max_ordinal {
6582                return Ok(());
6583            }
6584
6585            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6586            // are envelope_size bytes.
6587            let cur_offset: usize = (1 - 1) * envelope_size;
6588
6589            // Zero reserved fields.
6590            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6591
6592            // Safety:
6593            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6594            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6595            //   envelope_size bytes, there is always sufficient room.
6596            fidl::encoding::encode_in_envelope_optional::<Media, D>(
6597                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6598                encoder,
6599                offset + cur_offset,
6600                depth,
6601            )?;
6602
6603            _prev_end_offset = cur_offset + envelope_size;
6604            if 2 > max_ordinal {
6605                return Ok(());
6606            }
6607
6608            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6609            // are envelope_size bytes.
6610            let cur_offset: usize = (2 - 1) * envelope_size;
6611
6612            // Zero reserved fields.
6613            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6614
6615            // Safety:
6616            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6617            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6618            //   envelope_size bytes, there is always sufficient room.
6619            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6620                self.ip_versions
6621                    .as_ref()
6622                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6623                encoder,
6624                offset + cur_offset,
6625                depth,
6626            )?;
6627
6628            _prev_end_offset = cur_offset + envelope_size;
6629            if 3 > max_ordinal {
6630                return Ok(());
6631            }
6632
6633            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6634            // are envelope_size bytes.
6635            let cur_offset: usize = (3 - 1) * envelope_size;
6636
6637            // Zero reserved fields.
6638            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6639
6640            // Safety:
6641            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6642            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6643            //   envelope_size bytes, there is always sufficient room.
6644            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6645                self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6646                encoder,
6647                offset + cur_offset,
6648                depth,
6649            )?;
6650
6651            _prev_end_offset = cur_offset + envelope_size;
6652            if 4 > max_ordinal {
6653                return Ok(());
6654            }
6655
6656            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6657            // are envelope_size bytes.
6658            let cur_offset: usize = (4 - 1) * envelope_size;
6659
6660            // Zero reserved fields.
6661            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6662
6663            // Safety:
6664            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6665            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6666            //   envelope_size bytes, there is always sufficient room.
6667            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6668                self.exclude_local_proxies
6669                    .as_ref()
6670                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6671                encoder,
6672                offset + cur_offset,
6673                depth,
6674            )?;
6675
6676            _prev_end_offset = cur_offset + envelope_size;
6677
6678            Ok(())
6679        }
6680    }
6681
6682    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6683        for ServiceInstanceResolutionOptions
6684    {
6685        #[inline(always)]
6686        fn new_empty() -> Self {
6687            Self::default()
6688        }
6689
6690        unsafe fn decode(
6691            &mut self,
6692            decoder: &mut fidl::encoding::Decoder<'_, D>,
6693            offset: usize,
6694            mut depth: fidl::encoding::Depth,
6695        ) -> fidl::Result<()> {
6696            decoder.debug_check_bounds::<Self>(offset);
6697            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6698                None => return Err(fidl::Error::NotNullable),
6699                Some(len) => len,
6700            };
6701            // Calling decoder.out_of_line_offset(0) is not allowed.
6702            if len == 0 {
6703                return Ok(());
6704            };
6705            depth.increment()?;
6706            let envelope_size = 8;
6707            let bytes_len = len * envelope_size;
6708            let offset = decoder.out_of_line_offset(bytes_len)?;
6709            // Decode the envelope for each type.
6710            let mut _next_ordinal_to_read = 0;
6711            let mut next_offset = offset;
6712            let end_offset = offset + bytes_len;
6713            _next_ordinal_to_read += 1;
6714            if next_offset >= end_offset {
6715                return Ok(());
6716            }
6717
6718            // Decode unknown envelopes for gaps in ordinals.
6719            while _next_ordinal_to_read < 1 {
6720                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6721                _next_ordinal_to_read += 1;
6722                next_offset += envelope_size;
6723            }
6724
6725            let next_out_of_line = decoder.next_out_of_line();
6726            let handles_before = decoder.remaining_handles();
6727            if let Some((inlined, num_bytes, num_handles)) =
6728                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6729            {
6730                let member_inline_size =
6731                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6732                if inlined != (member_inline_size <= 4) {
6733                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6734                }
6735                let inner_offset;
6736                let mut inner_depth = depth.clone();
6737                if inlined {
6738                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6739                    inner_offset = next_offset;
6740                } else {
6741                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6742                    inner_depth.increment()?;
6743                }
6744                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6745                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6746                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6747                {
6748                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6749                }
6750                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6751                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6752                }
6753            }
6754
6755            next_offset += envelope_size;
6756            _next_ordinal_to_read += 1;
6757            if next_offset >= end_offset {
6758                return Ok(());
6759            }
6760
6761            // Decode unknown envelopes for gaps in ordinals.
6762            while _next_ordinal_to_read < 2 {
6763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6764                _next_ordinal_to_read += 1;
6765                next_offset += envelope_size;
6766            }
6767
6768            let next_out_of_line = decoder.next_out_of_line();
6769            let handles_before = decoder.remaining_handles();
6770            if let Some((inlined, num_bytes, num_handles)) =
6771                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6772            {
6773                let member_inline_size =
6774                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6775                if inlined != (member_inline_size <= 4) {
6776                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6777                }
6778                let inner_offset;
6779                let mut inner_depth = depth.clone();
6780                if inlined {
6781                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6782                    inner_offset = next_offset;
6783                } else {
6784                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6785                    inner_depth.increment()?;
6786                }
6787                let val_ref =
6788                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6789                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6791                {
6792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6793                }
6794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6796                }
6797            }
6798
6799            next_offset += envelope_size;
6800            _next_ordinal_to_read += 1;
6801            if next_offset >= end_offset {
6802                return Ok(());
6803            }
6804
6805            // Decode unknown envelopes for gaps in ordinals.
6806            while _next_ordinal_to_read < 3 {
6807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6808                _next_ordinal_to_read += 1;
6809                next_offset += envelope_size;
6810            }
6811
6812            let next_out_of_line = decoder.next_out_of_line();
6813            let handles_before = decoder.remaining_handles();
6814            if let Some((inlined, num_bytes, num_handles)) =
6815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6816            {
6817                let member_inline_size =
6818                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6819                if inlined != (member_inline_size <= 4) {
6820                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6821                }
6822                let inner_offset;
6823                let mut inner_depth = depth.clone();
6824                if inlined {
6825                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6826                    inner_offset = next_offset;
6827                } else {
6828                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6829                    inner_depth.increment()?;
6830                }
6831                let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
6832                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6833                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6834                {
6835                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6836                }
6837                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6838                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6839                }
6840            }
6841
6842            next_offset += envelope_size;
6843            _next_ordinal_to_read += 1;
6844            if next_offset >= end_offset {
6845                return Ok(());
6846            }
6847
6848            // Decode unknown envelopes for gaps in ordinals.
6849            while _next_ordinal_to_read < 4 {
6850                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6851                _next_ordinal_to_read += 1;
6852                next_offset += envelope_size;
6853            }
6854
6855            let next_out_of_line = decoder.next_out_of_line();
6856            let handles_before = decoder.remaining_handles();
6857            if let Some((inlined, num_bytes, num_handles)) =
6858                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6859            {
6860                let member_inline_size =
6861                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6862                if inlined != (member_inline_size <= 4) {
6863                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6864                }
6865                let inner_offset;
6866                let mut inner_depth = depth.clone();
6867                if inlined {
6868                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6869                    inner_offset = next_offset;
6870                } else {
6871                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6872                    inner_depth.increment()?;
6873                }
6874                let val_ref =
6875                    self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
6876                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6877                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6878                {
6879                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6880                }
6881                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6882                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6883                }
6884            }
6885
6886            next_offset += envelope_size;
6887
6888            // Decode the remaining unknown envelopes.
6889            while next_offset < end_offset {
6890                _next_ordinal_to_read += 1;
6891                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6892                next_offset += envelope_size;
6893            }
6894
6895            Ok(())
6896        }
6897    }
6898
6899    impl ServiceSubscriptionOptions {
6900        #[inline(always)]
6901        fn max_ordinal_present(&self) -> u64 {
6902            if let Some(_) = self.exclude_local_proxies {
6903                return 4;
6904            }
6905            if let Some(_) = self.exclude_local {
6906                return 3;
6907            }
6908            if let Some(_) = self.ip_versions {
6909                return 2;
6910            }
6911            if let Some(_) = self.media {
6912                return 1;
6913            }
6914            0
6915        }
6916    }
6917
6918    impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionOptions {
6919        type Borrowed<'a> = &'a Self;
6920        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6921            value
6922        }
6923    }
6924
6925    unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionOptions {
6926        type Owned = Self;
6927
6928        #[inline(always)]
6929        fn inline_align(_context: fidl::encoding::Context) -> usize {
6930            8
6931        }
6932
6933        #[inline(always)]
6934        fn inline_size(_context: fidl::encoding::Context) -> usize {
6935            16
6936        }
6937    }
6938
6939    unsafe impl<D: fidl::encoding::ResourceDialect>
6940        fidl::encoding::Encode<ServiceSubscriptionOptions, D> for &ServiceSubscriptionOptions
6941    {
6942        unsafe fn encode(
6943            self,
6944            encoder: &mut fidl::encoding::Encoder<'_, D>,
6945            offset: usize,
6946            mut depth: fidl::encoding::Depth,
6947        ) -> fidl::Result<()> {
6948            encoder.debug_check_bounds::<ServiceSubscriptionOptions>(offset);
6949            // Vector header
6950            let max_ordinal: u64 = self.max_ordinal_present();
6951            encoder.write_num(max_ordinal, offset);
6952            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6953            // Calling encoder.out_of_line_offset(0) is not allowed.
6954            if max_ordinal == 0 {
6955                return Ok(());
6956            }
6957            depth.increment()?;
6958            let envelope_size = 8;
6959            let bytes_len = max_ordinal as usize * envelope_size;
6960            #[allow(unused_variables)]
6961            let offset = encoder.out_of_line_offset(bytes_len);
6962            let mut _prev_end_offset: usize = 0;
6963            if 1 > max_ordinal {
6964                return Ok(());
6965            }
6966
6967            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6968            // are envelope_size bytes.
6969            let cur_offset: usize = (1 - 1) * envelope_size;
6970
6971            // Zero reserved fields.
6972            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6973
6974            // Safety:
6975            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6976            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6977            //   envelope_size bytes, there is always sufficient room.
6978            fidl::encoding::encode_in_envelope_optional::<Media, D>(
6979                self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6980                encoder,
6981                offset + cur_offset,
6982                depth,
6983            )?;
6984
6985            _prev_end_offset = cur_offset + envelope_size;
6986            if 2 > max_ordinal {
6987                return Ok(());
6988            }
6989
6990            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6991            // are envelope_size bytes.
6992            let cur_offset: usize = (2 - 1) * envelope_size;
6993
6994            // Zero reserved fields.
6995            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6996
6997            // Safety:
6998            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6999            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7000            //   envelope_size bytes, there is always sufficient room.
7001            fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
7002                self.ip_versions
7003                    .as_ref()
7004                    .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
7005                encoder,
7006                offset + cur_offset,
7007                depth,
7008            )?;
7009
7010            _prev_end_offset = cur_offset + envelope_size;
7011            if 3 > max_ordinal {
7012                return Ok(());
7013            }
7014
7015            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7016            // are envelope_size bytes.
7017            let cur_offset: usize = (3 - 1) * envelope_size;
7018
7019            // Zero reserved fields.
7020            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7021
7022            // Safety:
7023            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7024            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7025            //   envelope_size bytes, there is always sufficient room.
7026            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7027                self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7028                encoder,
7029                offset + cur_offset,
7030                depth,
7031            )?;
7032
7033            _prev_end_offset = cur_offset + envelope_size;
7034            if 4 > max_ordinal {
7035                return Ok(());
7036            }
7037
7038            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7039            // are envelope_size bytes.
7040            let cur_offset: usize = (4 - 1) * envelope_size;
7041
7042            // Zero reserved fields.
7043            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7044
7045            // Safety:
7046            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7047            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7048            //   envelope_size bytes, there is always sufficient room.
7049            fidl::encoding::encode_in_envelope_optional::<bool, D>(
7050                self.exclude_local_proxies
7051                    .as_ref()
7052                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7053                encoder,
7054                offset + cur_offset,
7055                depth,
7056            )?;
7057
7058            _prev_end_offset = cur_offset + envelope_size;
7059
7060            Ok(())
7061        }
7062    }
7063
7064    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7065        for ServiceSubscriptionOptions
7066    {
7067        #[inline(always)]
7068        fn new_empty() -> Self {
7069            Self::default()
7070        }
7071
7072        unsafe fn decode(
7073            &mut self,
7074            decoder: &mut fidl::encoding::Decoder<'_, D>,
7075            offset: usize,
7076            mut depth: fidl::encoding::Depth,
7077        ) -> fidl::Result<()> {
7078            decoder.debug_check_bounds::<Self>(offset);
7079            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7080                None => return Err(fidl::Error::NotNullable),
7081                Some(len) => len,
7082            };
7083            // Calling decoder.out_of_line_offset(0) is not allowed.
7084            if len == 0 {
7085                return Ok(());
7086            };
7087            depth.increment()?;
7088            let envelope_size = 8;
7089            let bytes_len = len * envelope_size;
7090            let offset = decoder.out_of_line_offset(bytes_len)?;
7091            // Decode the envelope for each type.
7092            let mut _next_ordinal_to_read = 0;
7093            let mut next_offset = offset;
7094            let end_offset = offset + bytes_len;
7095            _next_ordinal_to_read += 1;
7096            if next_offset >= end_offset {
7097                return Ok(());
7098            }
7099
7100            // Decode unknown envelopes for gaps in ordinals.
7101            while _next_ordinal_to_read < 1 {
7102                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7103                _next_ordinal_to_read += 1;
7104                next_offset += envelope_size;
7105            }
7106
7107            let next_out_of_line = decoder.next_out_of_line();
7108            let handles_before = decoder.remaining_handles();
7109            if let Some((inlined, num_bytes, num_handles)) =
7110                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7111            {
7112                let member_inline_size =
7113                    <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7114                if inlined != (member_inline_size <= 4) {
7115                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7116                }
7117                let inner_offset;
7118                let mut inner_depth = depth.clone();
7119                if inlined {
7120                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7121                    inner_offset = next_offset;
7122                } else {
7123                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7124                    inner_depth.increment()?;
7125                }
7126                let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
7127                fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
7128                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7129                {
7130                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7131                }
7132                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7133                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7134                }
7135            }
7136
7137            next_offset += envelope_size;
7138            _next_ordinal_to_read += 1;
7139            if next_offset >= end_offset {
7140                return Ok(());
7141            }
7142
7143            // Decode unknown envelopes for gaps in ordinals.
7144            while _next_ordinal_to_read < 2 {
7145                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7146                _next_ordinal_to_read += 1;
7147                next_offset += envelope_size;
7148            }
7149
7150            let next_out_of_line = decoder.next_out_of_line();
7151            let handles_before = decoder.remaining_handles();
7152            if let Some((inlined, num_bytes, num_handles)) =
7153                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7154            {
7155                let member_inline_size =
7156                    <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7157                if inlined != (member_inline_size <= 4) {
7158                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7159                }
7160                let inner_offset;
7161                let mut inner_depth = depth.clone();
7162                if inlined {
7163                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7164                    inner_offset = next_offset;
7165                } else {
7166                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7167                    inner_depth.increment()?;
7168                }
7169                let val_ref =
7170                    self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
7171                fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
7172                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7173                {
7174                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7175                }
7176                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7177                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7178                }
7179            }
7180
7181            next_offset += envelope_size;
7182            _next_ordinal_to_read += 1;
7183            if next_offset >= end_offset {
7184                return Ok(());
7185            }
7186
7187            // Decode unknown envelopes for gaps in ordinals.
7188            while _next_ordinal_to_read < 3 {
7189                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7190                _next_ordinal_to_read += 1;
7191                next_offset += envelope_size;
7192            }
7193
7194            let next_out_of_line = decoder.next_out_of_line();
7195            let handles_before = decoder.remaining_handles();
7196            if let Some((inlined, num_bytes, num_handles)) =
7197                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7198            {
7199                let member_inline_size =
7200                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7201                if inlined != (member_inline_size <= 4) {
7202                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7203                }
7204                let inner_offset;
7205                let mut inner_depth = depth.clone();
7206                if inlined {
7207                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7208                    inner_offset = next_offset;
7209                } else {
7210                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7211                    inner_depth.increment()?;
7212                }
7213                let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
7214                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7215                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7216                {
7217                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7218                }
7219                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7220                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7221                }
7222            }
7223
7224            next_offset += envelope_size;
7225            _next_ordinal_to_read += 1;
7226            if next_offset >= end_offset {
7227                return Ok(());
7228            }
7229
7230            // Decode unknown envelopes for gaps in ordinals.
7231            while _next_ordinal_to_read < 4 {
7232                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7233                _next_ordinal_to_read += 1;
7234                next_offset += envelope_size;
7235            }
7236
7237            let next_out_of_line = decoder.next_out_of_line();
7238            let handles_before = decoder.remaining_handles();
7239            if let Some((inlined, num_bytes, num_handles)) =
7240                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7241            {
7242                let member_inline_size =
7243                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7244                if inlined != (member_inline_size <= 4) {
7245                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7246                }
7247                let inner_offset;
7248                let mut inner_depth = depth.clone();
7249                if inlined {
7250                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7251                    inner_offset = next_offset;
7252                } else {
7253                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7254                    inner_depth.increment()?;
7255                }
7256                let val_ref =
7257                    self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
7258                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7259                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7260                {
7261                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7262                }
7263                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7264                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7265                }
7266            }
7267
7268            next_offset += envelope_size;
7269
7270            // Decode the remaining unknown envelopes.
7271            while next_offset < end_offset {
7272                _next_ordinal_to_read += 1;
7273                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7274                next_offset += envelope_size;
7275            }
7276
7277            Ok(())
7278        }
7279    }
7280}