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