fidl_next_fuchsia_component_sandbox/
fidl_next_fuchsia_component_sandbox.rs

1// DO NOT EDIT: This file is machine-generated by fidlgen
2#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5#[doc = " Describes the expected availability of the capability.\n\n Some capabilities may not be present on all system configurations. In those\n cases, the availability will be declared as `OPTIONAL` along the chains of\n exposes/offers/uses, and the capability would be routed from `void` on\n system configurations where it does not make sense to route or provide a\n particular capability (e.g. graphical capabilities on a headless system).\n"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u32)]
8pub enum Availability {
9    Required = 1,
10    Optional = 2,
11    SameAsTarget = 3,
12    Transitional = 4,
13}
14
15impl ::fidl_next::Encodable for Availability {
16    type Encoded = WireAvailability;
17}
18impl ::core::convert::TryFrom<u32> for Availability {
19    type Error = ::fidl_next::UnknownStrictEnumMemberError;
20    fn try_from(
21        value: u32,
22    ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
23        match value {
24            1 => Ok(Self::Required),
25            2 => Ok(Self::Optional),
26            3 => Ok(Self::SameAsTarget),
27            4 => Ok(Self::Transitional),
28
29            _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
30        }
31    }
32}
33
34unsafe impl<___E> ::fidl_next::Encode<___E> for Availability
35where
36    ___E: ?Sized,
37{
38    #[inline]
39    fn encode(
40        self,
41        encoder: &mut ___E,
42        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
43    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
45    }
46}
47
48unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Availability
49where
50    ___E: ?Sized,
51{
52    #[inline]
53    fn encode_ref(
54        &self,
55        encoder: &mut ___E,
56        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
57    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
58        ::fidl_next::munge!(let WireAvailability { value } = out);
59        let _ = value.write(::fidl_next::WireU32::from(match *self {
60            Self::Required => 1,
61
62            Self::Optional => 2,
63
64            Self::SameAsTarget => 3,
65
66            Self::Transitional => 4,
67        }));
68
69        Ok(())
70    }
71}
72
73impl ::core::convert::From<WireAvailability> for Availability {
74    fn from(wire: WireAvailability) -> Self {
75        match u32::from(wire.value) {
76            1 => Self::Required,
77
78            2 => Self::Optional,
79
80            3 => Self::SameAsTarget,
81
82            4 => Self::Transitional,
83
84            _ => unsafe { ::core::hint::unreachable_unchecked() },
85        }
86    }
87}
88
89impl ::fidl_next::FromWire<WireAvailability> for Availability {
90    #[inline]
91    fn from_wire(wire: WireAvailability) -> Self {
92        Self::from(wire)
93    }
94}
95
96impl ::fidl_next::IntoNatural for WireAvailability {
97    type Natural = Availability;
98}
99
100impl ::fidl_next::FromWireRef<WireAvailability> for Availability {
101    #[inline]
102    fn from_wire_ref(wire: &WireAvailability) -> Self {
103        Self::from(*wire)
104    }
105}
106
107/// The wire type corresponding to [`Availability`].
108#[derive(Clone, Copy, Debug, PartialEq, Eq)]
109#[repr(transparent)]
110pub struct WireAvailability {
111    value: ::fidl_next::WireU32,
112}
113
114unsafe impl ::fidl_next::Wire for WireAvailability {
115    type Decoded<'de> = Self;
116
117    #[inline]
118    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
119        // Wire enums have no padding
120    }
121}
122
123impl WireAvailability {
124    pub const REQUIRED: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(1) };
125
126    pub const OPTIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(2) };
127
128    pub const SAME_AS_TARGET: WireAvailability =
129        WireAvailability { value: ::fidl_next::WireU32(3) };
130
131    pub const TRANSITIONAL: WireAvailability = WireAvailability { value: ::fidl_next::WireU32(4) };
132}
133
134unsafe impl<___D> ::fidl_next::Decode<___D> for WireAvailability
135where
136    ___D: ?Sized,
137{
138    fn decode(
139        slot: ::fidl_next::Slot<'_, Self>,
140        _: &mut ___D,
141    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
142        ::fidl_next::munge!(let Self { value } = slot);
143
144        match u32::from(*value) {
145            1 | 2 | 3 | 4 => (),
146            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
147        }
148
149        Ok(())
150    }
151}
152
153impl ::core::convert::From<Availability> for WireAvailability {
154    fn from(natural: Availability) -> Self {
155        match natural {
156            Availability::Required => WireAvailability::REQUIRED,
157
158            Availability::Optional => WireAvailability::OPTIONAL,
159
160            Availability::SameAsTarget => WireAvailability::SAME_AS_TARGET,
161
162            Availability::Transitional => WireAvailability::TRANSITIONAL,
163        }
164    }
165}
166
167#[derive(PartialEq, Clone, Debug)]
168#[repr(C)]
169pub struct Unit {}
170
171impl ::fidl_next::Encodable for Unit {
172    type Encoded = WireUnit;
173}
174
175unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
176where
177    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
178{
179    #[inline]
180    fn encode(
181        self,
182        encoder_: &mut ___E,
183        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
184    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185        *out_ = ::core::mem::MaybeUninit::zeroed();
186
187        Ok(())
188    }
189}
190
191unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unit
192where
193    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
194{
195    #[inline]
196    fn encode_ref(
197        &self,
198        encoder_: &mut ___E,
199        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
200    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
201        ::fidl_next::munge! {
202            let Self::Encoded {
203
204                    _empty,
205
206
207            } = out_;
208        }
209
210        Ok(())
211    }
212}
213
214impl ::fidl_next::EncodableOption for Unit {
215    type EncodedOption = ::fidl_next::WireBox<'static, WireUnit>;
216}
217
218unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unit
219where
220    ___E: ::fidl_next::Encoder + ?Sized,
221    Unit: ::fidl_next::Encode<___E>,
222{
223    #[inline]
224    fn encode_option(
225        this: ::core::option::Option<Self>,
226        encoder: &mut ___E,
227        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
228    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
229        if let Some(inner) = this {
230            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
231            ::fidl_next::WireBox::encode_present(out);
232        } else {
233            ::fidl_next::WireBox::encode_absent(out);
234        }
235
236        Ok(())
237    }
238}
239
240unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unit
241where
242    ___E: ::fidl_next::Encoder + ?Sized,
243    Unit: ::fidl_next::EncodeRef<___E>,
244{
245    #[inline]
246    fn encode_option_ref(
247        this: ::core::option::Option<&Self>,
248        encoder: &mut ___E,
249        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
250    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
251        if let Some(inner) = this {
252            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
253            ::fidl_next::WireBox::encode_present(out);
254        } else {
255            ::fidl_next::WireBox::encode_absent(out);
256        }
257
258        Ok(())
259    }
260}
261
262impl ::fidl_next::FromWire<WireUnit> for Unit {
263    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireUnit, Self> =
264        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
265
266    #[inline]
267    fn from_wire(wire: WireUnit) -> Self {
268        Self {}
269    }
270}
271
272impl ::fidl_next::IntoNatural for WireUnit {
273    type Natural = Unit;
274}
275
276impl ::fidl_next::FromWireRef<WireUnit> for Unit {
277    #[inline]
278    fn from_wire_ref(wire: &WireUnit) -> Self {
279        Self {}
280    }
281}
282
283/// The wire type corresponding to [`Unit`].
284#[derive(Clone, Debug)]
285#[repr(C)]
286pub struct WireUnit {
287    _empty: fidl_next::WireEmptyStructPlaceholder,
288}
289static_assertions::const_assert_eq!(std::mem::size_of::<WireUnit>(), 1);
290static_assertions::const_assert_eq!(std::mem::align_of::<WireUnit>(), 1);
291
292unsafe impl ::fidl_next::Wire for WireUnit {
293    type Decoded<'de> = WireUnit;
294
295    #[inline]
296    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
297        ::fidl_next::munge! {
298            let Self {
299
300                    _empty,
301
302
303            } = &mut *out_;
304        }
305    }
306}
307
308unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnit
309where
310    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
311{
312    fn decode(
313        slot_: ::fidl_next::Slot<'_, Self>,
314        decoder_: &mut ___D,
315    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
316        ::fidl_next::munge! {
317            let Self {
318
319                    mut _empty,
320
321
322            } = slot_;
323        }
324
325        if _empty.as_bytes() != &[0u8] {
326            return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
327        }
328
329        Ok(())
330    }
331}
332
333#[doc = " Maximum number of bytes in a [Data].\n"]
334pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
335
336#[derive(PartialEq, Clone, Debug)]
337pub enum Data {
338    Bytes(::std::vec::Vec<u8>),
339
340    String(::std::string::String),
341
342    Int64(i64),
343
344    Uint64(u64),
345
346    UnknownOrdinal_(u64),
347}
348
349impl ::fidl_next::Encodable for Data {
350    type Encoded = WireData<'static>;
351}
352
353unsafe impl<___E> ::fidl_next::Encode<___E> for Data
354where
355    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
356    ___E: ::fidl_next::Encoder,
357{
358    #[inline]
359    fn encode(
360        self,
361        encoder: &mut ___E,
362        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
363    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
364        ::fidl_next::munge!(let WireData { raw, _phantom: _ } = out);
365
366        match self {
367            Self::Bytes(value) => {
368                ::fidl_next::RawWireUnion::encode_as::<___E, ::std::vec::Vec<u8>>(
369                    value, 1, encoder, raw,
370                )?
371            }
372
373            Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
374                ___E,
375                ::std::string::String,
376            >(value, 2, encoder, raw)?,
377
378            Self::Int64(value) => {
379                ::fidl_next::RawWireUnion::encode_as::<___E, i64>(value, 3, encoder, raw)?
380            }
381
382            Self::Uint64(value) => {
383                ::fidl_next::RawWireUnion::encode_as::<___E, u64>(value, 4, encoder, raw)?
384            }
385
386            Self::UnknownOrdinal_(ordinal) => {
387                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
388            }
389        }
390
391        Ok(())
392    }
393}
394
395unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Data
396where
397    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
398    ___E: ::fidl_next::Encoder,
399{
400    #[inline]
401    fn encode_ref(
402        &self,
403        encoder: &mut ___E,
404        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
405    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
406        ::fidl_next::munge!(let WireData { raw, _phantom: _ } = out);
407
408        match self {
409            Self::Bytes(value) => {
410                ::fidl_next::RawWireUnion::encode_as::<___E, &::std::vec::Vec<u8>>(
411                    value, 1, encoder, raw,
412                )?
413            }
414
415            Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
416                ___E,
417                &::std::string::String,
418            >(value, 2, encoder, raw)?,
419
420            Self::Int64(value) => {
421                ::fidl_next::RawWireUnion::encode_as::<___E, &i64>(value, 3, encoder, raw)?
422            }
423
424            Self::Uint64(value) => {
425                ::fidl_next::RawWireUnion::encode_as::<___E, &u64>(value, 4, encoder, raw)?
426            }
427
428            Self::UnknownOrdinal_(ordinal) => {
429                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
430            }
431        }
432
433        Ok(())
434    }
435}
436
437impl ::fidl_next::EncodableOption for Data {
438    type EncodedOption = WireOptionalData<'static>;
439}
440
441unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Data
442where
443    ___E: ?Sized,
444    Data: ::fidl_next::Encode<___E>,
445{
446    #[inline]
447    fn encode_option(
448        this: ::core::option::Option<Self>,
449        encoder: &mut ___E,
450        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
451    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
452        ::fidl_next::munge!(let WireOptionalData { raw, _phantom: _ } = &mut *out);
453
454        if let Some(inner) = this {
455            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
456            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
457        } else {
458            ::fidl_next::RawWireUnion::encode_absent(raw);
459        }
460
461        Ok(())
462    }
463}
464
465unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Data
466where
467    ___E: ?Sized,
468    Data: ::fidl_next::EncodeRef<___E>,
469{
470    #[inline]
471    fn encode_option_ref(
472        this: ::core::option::Option<&Self>,
473        encoder: &mut ___E,
474        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
475    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
476        ::fidl_next::munge!(let WireOptionalData { raw, _phantom: _ } = &mut *out);
477
478        if let Some(inner) = this {
479            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
480            ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out)?;
481        } else {
482            ::fidl_next::RawWireUnion::encode_absent(raw);
483        }
484
485        Ok(())
486    }
487}
488
489impl<'de> ::fidl_next::FromWire<WireData<'de>> for Data {
490    #[inline]
491    fn from_wire(wire: WireData<'de>) -> Self {
492        let wire = ::core::mem::ManuallyDrop::new(wire);
493        match wire.raw.ordinal() {
494            1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
495                wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
496            })),
497
498            2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
499                wire.raw.get().read_unchecked::<::fidl_next::WireString<'de>>()
500            })),
501
502            3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
503                wire.raw.get().read_unchecked::<::fidl_next::WireI64>()
504            })),
505
506            4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
507                wire.raw.get().read_unchecked::<::fidl_next::WireU64>()
508            })),
509
510            _ => unsafe { ::core::hint::unreachable_unchecked() },
511        }
512    }
513}
514
515impl<'de> ::fidl_next::IntoNatural for WireData<'de> {
516    type Natural = Data;
517}
518
519impl<'de> ::fidl_next::FromWireRef<WireData<'de>> for Data {
520    #[inline]
521    fn from_wire_ref(wire: &WireData<'de>) -> Self {
522        match wire.raw.ordinal() {
523            1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
524                wire.raw.get().deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
525            })),
526
527            2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
528                wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
529            })),
530
531            3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
532                wire.raw.get().deref_unchecked::<::fidl_next::WireI64>()
533            })),
534
535            4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
536                wire.raw.get().deref_unchecked::<::fidl_next::WireU64>()
537            })),
538
539            _ => unsafe { ::core::hint::unreachable_unchecked() },
540        }
541    }
542}
543
544impl<'de> ::fidl_next::FromWireOption<WireOptionalData<'de>> for Data {
545    #[inline]
546    fn from_wire_option(wire: WireOptionalData<'de>) -> ::core::option::Option<Self> {
547        if let Some(inner) = wire.into_option() {
548            Some(::fidl_next::FromWire::from_wire(inner))
549        } else {
550            None
551        }
552    }
553}
554
555impl<'de> ::fidl_next::IntoNatural for WireOptionalData<'de> {
556    type Natural = ::core::option::Option<Data>;
557}
558
559impl<'de> ::fidl_next::FromWireOption<WireOptionalData<'de>> for Box<Data> {
560    #[inline]
561    fn from_wire_option(wire: WireOptionalData<'de>) -> ::core::option::Option<Self> {
562        <Data as ::fidl_next::FromWireOption<WireOptionalData<'de>>>::from_wire_option(wire)
563            .map(Box::new)
564    }
565}
566
567impl<'de> ::fidl_next::FromWireOptionRef<WireOptionalData<'de>> for Box<Data> {
568    #[inline]
569    fn from_wire_option_ref(wire: &WireOptionalData<'de>) -> ::core::option::Option<Self> {
570        if let Some(inner) = wire.as_ref() {
571            Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
572        } else {
573            None
574        }
575    }
576}
577
578/// The wire type corresponding to [`Data`].
579#[repr(transparent)]
580pub struct WireData<'de> {
581    raw: ::fidl_next::RawWireUnion,
582    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
583}
584
585impl<'de> Drop for WireData<'de> {
586    fn drop(&mut self) {
587        match self.raw.ordinal() {
588            1 => {
589                let _ =
590                    unsafe { self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>() };
591            }
592
593            2 => {
594                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireString<'de>>() };
595            }
596
597            3 => {
598                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI64>() };
599            }
600
601            4 => {
602                let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU64>() };
603            }
604
605            _ => (),
606        }
607    }
608}
609
610unsafe impl ::fidl_next::Wire for WireData<'static> {
611    type Decoded<'de> = WireData<'de>;
612
613    #[inline]
614    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
615        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
616        ::fidl_next::RawWireUnion::zero_padding(raw);
617    }
618}
619
620pub mod data {
621    pub enum Ref<'de> {
622        Bytes(&'de ::fidl_next::WireVector<'de, u8>),
623
624        String(&'de ::fidl_next::WireString<'de>),
625
626        Int64(&'de ::fidl_next::WireI64),
627
628        Uint64(&'de ::fidl_next::WireU64),
629
630        UnknownOrdinal_(u64),
631    }
632}
633
634impl<'de> WireData<'de> {
635    pub fn as_ref(&self) -> crate::data::Ref<'_> {
636        match self.raw.ordinal() {
637            1 => crate::data::Ref::Bytes(unsafe {
638                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
639            }),
640
641            2 => crate::data::Ref::String(unsafe {
642                self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
643            }),
644
645            3 => crate::data::Ref::Int64(unsafe {
646                self.raw.get().deref_unchecked::<::fidl_next::WireI64>()
647            }),
648
649            4 => crate::data::Ref::Uint64(unsafe {
650                self.raw.get().deref_unchecked::<::fidl_next::WireU64>()
651            }),
652
653            unknown => crate::data::Ref::UnknownOrdinal_(unknown),
654        }
655    }
656}
657
658unsafe impl<___D> ::fidl_next::Decode<___D> for WireData<'static>
659where
660    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
661    ___D: ::fidl_next::Decoder,
662{
663    fn decode(
664        mut slot: ::fidl_next::Slot<'_, Self>,
665        decoder: &mut ___D,
666    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
667        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
668        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
669            1 => {
670                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
671                    raw, decoder,
672                )?
673            }
674
675            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
676                raw, decoder,
677            )?,
678
679            3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,
680
681            4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,
682
683            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
684        }
685
686        Ok(())
687    }
688}
689
690impl<'de> ::core::fmt::Debug for WireData<'de> {
691    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
692        match self.raw.ordinal() {
693            1 => unsafe {
694                self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
695            },
696            2 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f) },
697            3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
698            4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
699            _ => unsafe { ::core::hint::unreachable_unchecked() },
700        }
701    }
702}
703
704#[repr(transparent)]
705pub struct WireOptionalData<'de> {
706    raw: ::fidl_next::RawWireUnion,
707    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
708}
709
710unsafe impl ::fidl_next::Wire for WireOptionalData<'static> {
711    type Decoded<'de> = WireOptionalData<'de>;
712
713    #[inline]
714    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
715        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
716        ::fidl_next::RawWireUnion::zero_padding(raw);
717    }
718}
719
720impl<'de> WireOptionalData<'de> {
721    pub fn is_some(&self) -> bool {
722        self.raw.is_some()
723    }
724
725    pub fn is_none(&self) -> bool {
726        self.raw.is_none()
727    }
728
729    pub fn as_ref(&self) -> ::core::option::Option<&WireData<'de>> {
730        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
731    }
732
733    pub fn into_option(self) -> ::core::option::Option<WireData<'de>> {
734        if self.is_some() {
735            Some(WireData { raw: self.raw, _phantom: ::core::marker::PhantomData })
736        } else {
737            None
738        }
739    }
740}
741
742unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalData<'static>
743where
744    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
745    ___D: ::fidl_next::Decoder,
746{
747    fn decode(
748        mut slot: ::fidl_next::Slot<'_, Self>,
749        decoder: &mut ___D,
750    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
751        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
752        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
753            1 => {
754                ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireVector<'static, u8>>(
755                    raw, decoder,
756                )?
757            }
758
759            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
760                raw, decoder,
761            )?,
762
763            3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(raw, decoder)?,
764
765            4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(raw, decoder)?,
766
767            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
768            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
769        }
770
771        Ok(())
772    }
773}
774
775impl<'de> ::core::fmt::Debug for WireOptionalData<'de> {
776    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
777        self.as_ref().fmt(f)
778    }
779}
780
781#[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
782pub type Token = ::fidl_next::fuchsia::zx::EventPair;
783
784/// The wire type corresponding to [`Token`].
785pub type WireToken = ::fidl_next::fuchsia::WireEventPair;
786
787#[derive(PartialEq, Debug)]
788#[repr(C)]
789pub struct DictionaryRef {
790    pub token: ::fidl_next::fuchsia::zx::EventPair,
791}
792
793impl ::fidl_next::Encodable for DictionaryRef {
794    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDictionaryRef> = unsafe {
795        ::fidl_next::CopyOptimization::enable_if(
796            true
797
798                && <
799                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
800                >::COPY_OPTIMIZATION.is_enabled()
801
802        )
803    };
804
805    type Encoded = WireDictionaryRef;
806}
807
808unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRef
809where
810    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
811    ___E: ::fidl_next::fuchsia::HandleEncoder,
812{
813    #[inline]
814    fn encode(
815        self,
816        encoder_: &mut ___E,
817        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
818    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
819        ::fidl_next::munge! {
820            let Self::Encoded {
821                token,
822
823            } = out_;
824        }
825
826        ::fidl_next::Encode::encode(self.token, encoder_, token)?;
827
828        Ok(())
829    }
830}
831
832impl ::fidl_next::EncodableOption for DictionaryRef {
833    type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryRef>;
834}
835
836unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRef
837where
838    ___E: ::fidl_next::Encoder + ?Sized,
839    DictionaryRef: ::fidl_next::Encode<___E>,
840{
841    #[inline]
842    fn encode_option(
843        this: ::core::option::Option<Self>,
844        encoder: &mut ___E,
845        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
846    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
847        if let Some(inner) = this {
848            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
849            ::fidl_next::WireBox::encode_present(out);
850        } else {
851            ::fidl_next::WireBox::encode_absent(out);
852        }
853
854        Ok(())
855    }
856}
857
858impl ::fidl_next::FromWire<WireDictionaryRef> for DictionaryRef {
859    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDictionaryRef, Self> = unsafe {
860        ::fidl_next::CopyOptimization::enable_if(
861            true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
862                ::fidl_next::fuchsia::WireEventPair,
863            >>::COPY_OPTIMIZATION
864                .is_enabled(),
865        )
866    };
867
868    #[inline]
869    fn from_wire(wire: WireDictionaryRef) -> Self {
870        Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
871    }
872}
873
874impl ::fidl_next::IntoNatural for WireDictionaryRef {
875    type Natural = DictionaryRef;
876}
877
878/// The wire type corresponding to [`DictionaryRef`].
879#[derive(Debug)]
880#[repr(C)]
881pub struct WireDictionaryRef {
882    pub token: ::fidl_next::fuchsia::WireEventPair,
883}
884static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryRef>(), 4);
885static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryRef>(), 4);
886
887static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryRef, token), 0);
888
889unsafe impl ::fidl_next::Wire for WireDictionaryRef {
890    type Decoded<'de> = WireDictionaryRef;
891
892    #[inline]
893    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
894        ::fidl_next::munge! {
895            let Self {
896
897                token,
898
899            } = &mut *out_;
900        }
901
902        ::fidl_next::Wire::zero_padding(token);
903    }
904}
905
906unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryRef
907where
908    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
909    ___D: ::fidl_next::fuchsia::HandleDecoder,
910{
911    fn decode(
912        slot_: ::fidl_next::Slot<'_, Self>,
913        decoder_: &mut ___D,
914    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
915        ::fidl_next::munge! {
916            let Self {
917
918                mut token,
919
920            } = slot_;
921        }
922
923        ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
924
925        Ok(())
926    }
927}
928
929#[derive(PartialEq, Debug)]
930#[repr(C)]
931pub struct Connector {
932    pub token: ::fidl_next::fuchsia::zx::EventPair,
933}
934
935impl ::fidl_next::Encodable for Connector {
936    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireConnector> = unsafe {
937        ::fidl_next::CopyOptimization::enable_if(
938            true
939
940                && <
941                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
942                >::COPY_OPTIMIZATION.is_enabled()
943
944        )
945    };
946
947    type Encoded = WireConnector;
948}
949
950unsafe impl<___E> ::fidl_next::Encode<___E> for Connector
951where
952    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
953    ___E: ::fidl_next::fuchsia::HandleEncoder,
954{
955    #[inline]
956    fn encode(
957        self,
958        encoder_: &mut ___E,
959        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
960    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
961        ::fidl_next::munge! {
962            let Self::Encoded {
963                token,
964
965            } = out_;
966        }
967
968        ::fidl_next::Encode::encode(self.token, encoder_, token)?;
969
970        Ok(())
971    }
972}
973
974impl ::fidl_next::EncodableOption for Connector {
975    type EncodedOption = ::fidl_next::WireBox<'static, WireConnector>;
976}
977
978unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Connector
979where
980    ___E: ::fidl_next::Encoder + ?Sized,
981    Connector: ::fidl_next::Encode<___E>,
982{
983    #[inline]
984    fn encode_option(
985        this: ::core::option::Option<Self>,
986        encoder: &mut ___E,
987        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
988    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
989        if let Some(inner) = this {
990            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
991            ::fidl_next::WireBox::encode_present(out);
992        } else {
993            ::fidl_next::WireBox::encode_absent(out);
994        }
995
996        Ok(())
997    }
998}
999
1000impl ::fidl_next::FromWire<WireConnector> for Connector {
1001    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireConnector, Self> = unsafe {
1002        ::fidl_next::CopyOptimization::enable_if(
1003            true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1004                ::fidl_next::fuchsia::WireEventPair,
1005            >>::COPY_OPTIMIZATION
1006                .is_enabled(),
1007        )
1008    };
1009
1010    #[inline]
1011    fn from_wire(wire: WireConnector) -> Self {
1012        Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1013    }
1014}
1015
1016impl ::fidl_next::IntoNatural for WireConnector {
1017    type Natural = Connector;
1018}
1019
1020/// The wire type corresponding to [`Connector`].
1021#[derive(Debug)]
1022#[repr(C)]
1023pub struct WireConnector {
1024    pub token: ::fidl_next::fuchsia::WireEventPair,
1025}
1026static_assertions::const_assert_eq!(std::mem::size_of::<WireConnector>(), 4);
1027static_assertions::const_assert_eq!(std::mem::align_of::<WireConnector>(), 4);
1028
1029static_assertions::const_assert_eq!(std::mem::offset_of!(WireConnector, token), 0);
1030
1031unsafe impl ::fidl_next::Wire for WireConnector {
1032    type Decoded<'de> = WireConnector;
1033
1034    #[inline]
1035    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1036        ::fidl_next::munge! {
1037            let Self {
1038
1039                token,
1040
1041            } = &mut *out_;
1042        }
1043
1044        ::fidl_next::Wire::zero_padding(token);
1045    }
1046}
1047
1048unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnector
1049where
1050    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1051    ___D: ::fidl_next::fuchsia::HandleDecoder,
1052{
1053    fn decode(
1054        slot_: ::fidl_next::Slot<'_, Self>,
1055        decoder_: &mut ___D,
1056    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1057        ::fidl_next::munge! {
1058            let Self {
1059
1060                mut token,
1061
1062            } = slot_;
1063        }
1064
1065        ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1066
1067        Ok(())
1068    }
1069}
1070
1071#[derive(PartialEq, Debug)]
1072#[repr(C)]
1073pub struct DirConnector {
1074    pub token: ::fidl_next::fuchsia::zx::EventPair,
1075}
1076
1077impl ::fidl_next::Encodable for DirConnector {
1078    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirConnector> = unsafe {
1079        ::fidl_next::CopyOptimization::enable_if(
1080            true
1081
1082                && <
1083                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
1084                >::COPY_OPTIMIZATION.is_enabled()
1085
1086        )
1087    };
1088
1089    type Encoded = WireDirConnector;
1090}
1091
1092unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnector
1093where
1094    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1095    ___E: ::fidl_next::fuchsia::HandleEncoder,
1096{
1097    #[inline]
1098    fn encode(
1099        self,
1100        encoder_: &mut ___E,
1101        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1102    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1103        ::fidl_next::munge! {
1104            let Self::Encoded {
1105                token,
1106
1107            } = out_;
1108        }
1109
1110        ::fidl_next::Encode::encode(self.token, encoder_, token)?;
1111
1112        Ok(())
1113    }
1114}
1115
1116impl ::fidl_next::EncodableOption for DirConnector {
1117    type EncodedOption = ::fidl_next::WireBox<'static, WireDirConnector>;
1118}
1119
1120unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnector
1121where
1122    ___E: ::fidl_next::Encoder + ?Sized,
1123    DirConnector: ::fidl_next::Encode<___E>,
1124{
1125    #[inline]
1126    fn encode_option(
1127        this: ::core::option::Option<Self>,
1128        encoder: &mut ___E,
1129        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1130    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1131        if let Some(inner) = this {
1132            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1133            ::fidl_next::WireBox::encode_present(out);
1134        } else {
1135            ::fidl_next::WireBox::encode_absent(out);
1136        }
1137
1138        Ok(())
1139    }
1140}
1141
1142impl ::fidl_next::FromWire<WireDirConnector> for DirConnector {
1143    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirConnector, Self> = unsafe {
1144        ::fidl_next::CopyOptimization::enable_if(
1145            true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1146                ::fidl_next::fuchsia::WireEventPair,
1147            >>::COPY_OPTIMIZATION
1148                .is_enabled(),
1149        )
1150    };
1151
1152    #[inline]
1153    fn from_wire(wire: WireDirConnector) -> Self {
1154        Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1155    }
1156}
1157
1158impl ::fidl_next::IntoNatural for WireDirConnector {
1159    type Natural = DirConnector;
1160}
1161
1162/// The wire type corresponding to [`DirConnector`].
1163#[derive(Debug)]
1164#[repr(C)]
1165pub struct WireDirConnector {
1166    pub token: ::fidl_next::fuchsia::WireEventPair,
1167}
1168static_assertions::const_assert_eq!(std::mem::size_of::<WireDirConnector>(), 4);
1169static_assertions::const_assert_eq!(std::mem::align_of::<WireDirConnector>(), 4);
1170
1171static_assertions::const_assert_eq!(std::mem::offset_of!(WireDirConnector, token), 0);
1172
1173unsafe impl ::fidl_next::Wire for WireDirConnector {
1174    type Decoded<'de> = WireDirConnector;
1175
1176    #[inline]
1177    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1178        ::fidl_next::munge! {
1179            let Self {
1180
1181                token,
1182
1183            } = &mut *out_;
1184        }
1185
1186        ::fidl_next::Wire::zero_padding(token);
1187    }
1188}
1189
1190unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirConnector
1191where
1192    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1193    ___D: ::fidl_next::fuchsia::HandleDecoder,
1194{
1195    fn decode(
1196        slot_: ::fidl_next::Slot<'_, Self>,
1197        decoder_: &mut ___D,
1198    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1199        ::fidl_next::munge! {
1200            let Self {
1201
1202                mut token,
1203
1204            } = slot_;
1205        }
1206
1207        ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1208
1209        Ok(())
1210    }
1211}
1212
1213#[derive(PartialEq, Debug)]
1214#[repr(C)]
1215pub struct DirEntry {
1216    pub token: ::fidl_next::fuchsia::zx::EventPair,
1217}
1218
1219impl ::fidl_next::Encodable for DirEntry {
1220    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirEntry> = unsafe {
1221        ::fidl_next::CopyOptimization::enable_if(
1222            true
1223
1224                && <
1225                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
1226                >::COPY_OPTIMIZATION.is_enabled()
1227
1228        )
1229    };
1230
1231    type Encoded = WireDirEntry;
1232}
1233
1234unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntry
1235where
1236    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1237    ___E: ::fidl_next::fuchsia::HandleEncoder,
1238{
1239    #[inline]
1240    fn encode(
1241        self,
1242        encoder_: &mut ___E,
1243        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1244    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1245        ::fidl_next::munge! {
1246            let Self::Encoded {
1247                token,
1248
1249            } = out_;
1250        }
1251
1252        ::fidl_next::Encode::encode(self.token, encoder_, token)?;
1253
1254        Ok(())
1255    }
1256}
1257
1258impl ::fidl_next::EncodableOption for DirEntry {
1259    type EncodedOption = ::fidl_next::WireBox<'static, WireDirEntry>;
1260}
1261
1262unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntry
1263where
1264    ___E: ::fidl_next::Encoder + ?Sized,
1265    DirEntry: ::fidl_next::Encode<___E>,
1266{
1267    #[inline]
1268    fn encode_option(
1269        this: ::core::option::Option<Self>,
1270        encoder: &mut ___E,
1271        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1272    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1273        if let Some(inner) = this {
1274            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1275            ::fidl_next::WireBox::encode_present(out);
1276        } else {
1277            ::fidl_next::WireBox::encode_absent(out);
1278        }
1279
1280        Ok(())
1281    }
1282}
1283
1284impl ::fidl_next::FromWire<WireDirEntry> for DirEntry {
1285    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirEntry, Self> = unsafe {
1286        ::fidl_next::CopyOptimization::enable_if(
1287            true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
1288                ::fidl_next::fuchsia::WireEventPair,
1289            >>::COPY_OPTIMIZATION
1290                .is_enabled(),
1291        )
1292    };
1293
1294    #[inline]
1295    fn from_wire(wire: WireDirEntry) -> Self {
1296        Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
1297    }
1298}
1299
1300impl ::fidl_next::IntoNatural for WireDirEntry {
1301    type Natural = DirEntry;
1302}
1303
1304/// The wire type corresponding to [`DirEntry`].
1305#[derive(Debug)]
1306#[repr(C)]
1307pub struct WireDirEntry {
1308    pub token: ::fidl_next::fuchsia::WireEventPair,
1309}
1310static_assertions::const_assert_eq!(std::mem::size_of::<WireDirEntry>(), 4);
1311static_assertions::const_assert_eq!(std::mem::align_of::<WireDirEntry>(), 4);
1312
1313static_assertions::const_assert_eq!(std::mem::offset_of!(WireDirEntry, token), 0);
1314
1315unsafe impl ::fidl_next::Wire for WireDirEntry {
1316    type Decoded<'de> = WireDirEntry;
1317
1318    #[inline]
1319    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
1320        ::fidl_next::munge! {
1321            let Self {
1322
1323                token,
1324
1325            } = &mut *out_;
1326        }
1327
1328        ::fidl_next::Wire::zero_padding(token);
1329    }
1330}
1331
1332unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirEntry
1333where
1334    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1335    ___D: ::fidl_next::fuchsia::HandleDecoder,
1336{
1337    fn decode(
1338        slot_: ::fidl_next::Slot<'_, Self>,
1339        decoder_: &mut ___D,
1340    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1341        ::fidl_next::munge! {
1342            let Self {
1343
1344                mut token,
1345
1346            } = slot_;
1347        }
1348
1349        ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
1350
1351        Ok(())
1352    }
1353}
1354
1355#[derive(PartialEq, Debug)]
1356pub enum Capability {
1357    Unit(crate::Unit),
1358
1359    Handle(::fidl_next::fuchsia::zx::Handle),
1360
1361    Data(crate::Data),
1362
1363    Dictionary(crate::DictionaryRef),
1364
1365    Connector(crate::Connector),
1366
1367    DirConnector(crate::DirConnector),
1368
1369    Directory(
1370        ::fidl_next::ClientEnd<
1371            ::fidl_next_fuchsia_io::Directory,
1372            ::fidl_next::fuchsia::zx::Channel,
1373        >,
1374    ),
1375
1376    DirEntry(crate::DirEntry),
1377
1378    ConnectorRouter(
1379        ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1380    ),
1381
1382    DictionaryRouter(
1383        ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
1384    ),
1385
1386    DirEntryRouter(
1387        ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
1388    ),
1389
1390    DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
1391
1392    DirConnectorRouter(
1393        ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1394    ),
1395
1396    UnknownOrdinal_(u64),
1397}
1398
1399impl ::fidl_next::Encodable for Capability {
1400    type Encoded = WireCapability<'static>;
1401}
1402
1403unsafe impl<___E> ::fidl_next::Encode<___E> for Capability
1404where
1405    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1406    ___E: ::fidl_next::Encoder,
1407    ___E: ::fidl_next::fuchsia::HandleEncoder,
1408{
1409    #[inline]
1410    fn encode(
1411        self,
1412        encoder: &mut ___E,
1413        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1414    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1415        ::fidl_next::munge!(let WireCapability { raw, _phantom: _ } = out);
1416
1417        match self {
1418            Self::Unit(value) => {
1419                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Unit>(value, 1, encoder, raw)?
1420            }
1421
1422            Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
1423                ___E,
1424                ::fidl_next::fuchsia::zx::Handle,
1425            >(value, 2, encoder, raw)?,
1426
1427            Self::Data(value) => {
1428                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Data>(value, 3, encoder, raw)?
1429            }
1430
1431            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
1432                ___E,
1433                crate::DictionaryRef,
1434            >(value, 4, encoder, raw)?,
1435
1436            Self::Connector(value) => {
1437                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Connector>(
1438                    value, 5, encoder, raw,
1439                )?
1440            }
1441
1442            Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
1443                ___E,
1444                crate::DirConnector,
1445            >(value, 6, encoder, raw)?,
1446
1447            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
1448                ___E,
1449                ::fidl_next::ClientEnd<
1450                    ::fidl_next_fuchsia_io::Directory,
1451                    ::fidl_next::fuchsia::zx::Channel,
1452                >,
1453            >(value, 7, encoder, raw)?,
1454
1455            Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<___E, crate::DirEntry>(
1456                value, 8, encoder, raw,
1457            )?,
1458
1459            Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1460                ___E,
1461                ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
1462            >(value, 9, encoder, raw)?,
1463
1464            Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1465                ___E,
1466                ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
1467            >(value, 10, encoder, raw)?,
1468
1469            Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1470                ___E,
1471                ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
1472            >(value, 11, encoder, raw)?,
1473
1474            Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1475                ___E,
1476                ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>,
1477            >(value, 12, encoder, raw)?,
1478
1479            Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
1480                ___E,
1481                ::fidl_next::ClientEnd<
1482                    crate::DirConnectorRouter,
1483                    ::fidl_next::fuchsia::zx::Channel,
1484                >,
1485            >(value, 13, encoder, raw)?,
1486
1487            Self::UnknownOrdinal_(ordinal) => {
1488                return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1489            }
1490        }
1491
1492        Ok(())
1493    }
1494}
1495
1496impl ::fidl_next::EncodableOption for Capability {
1497    type EncodedOption = WireOptionalCapability<'static>;
1498}
1499
1500unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Capability
1501where
1502    ___E: ?Sized,
1503    Capability: ::fidl_next::Encode<___E>,
1504{
1505    #[inline]
1506    fn encode_option(
1507        this: ::core::option::Option<Self>,
1508        encoder: &mut ___E,
1509        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1510    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1511        ::fidl_next::munge!(let WireOptionalCapability { raw, _phantom: _ } = &mut *out);
1512
1513        if let Some(inner) = this {
1514            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1515            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
1516        } else {
1517            ::fidl_next::RawWireUnion::encode_absent(raw);
1518        }
1519
1520        Ok(())
1521    }
1522}
1523
1524impl<'de> ::fidl_next::FromWire<WireCapability<'de>> for Capability {
1525    #[inline]
1526    fn from_wire(wire: WireCapability<'de>) -> Self {
1527        let wire = ::core::mem::ManuallyDrop::new(wire);
1528        match wire.raw.ordinal() {
1529            1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
1530                wire.raw.get().read_unchecked::<crate::WireUnit>()
1531            })),
1532
1533            2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
1534                wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
1535            })),
1536
1537            3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
1538                wire.raw.get().read_unchecked::<crate::WireData<'de>>()
1539            })),
1540
1541            4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
1542                wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
1543            })),
1544
1545            5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1546                wire.raw.get().read_unchecked::<crate::WireConnector>()
1547            })),
1548
1549            6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
1550                wire.raw.get().read_unchecked::<crate::WireDirConnector>()
1551            })),
1552
1553            7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1554                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1555                    ::fidl_next_fuchsia_io::Directory,
1556                    ::fidl_next::fuchsia::WireChannel,
1557                >>()
1558            })),
1559
1560            8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
1561                wire.raw.get().read_unchecked::<crate::WireDirEntry>()
1562            })),
1563
1564            9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1565                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1566                    crate::ConnectorRouter,
1567                    ::fidl_next::fuchsia::WireChannel,
1568                >>()
1569            })),
1570
1571            10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
1572                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1573                    crate::DictionaryRouter,
1574                    ::fidl_next::fuchsia::WireChannel,
1575                >>()
1576            })),
1577
1578            11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
1579                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>>()
1580            })),
1581
1582            12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
1583                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1584            })),
1585
1586            13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1587                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1588                    crate::DirConnectorRouter,
1589                    ::fidl_next::fuchsia::WireChannel,
1590                >>()
1591            })),
1592
1593            _ => unsafe { ::core::hint::unreachable_unchecked() },
1594        }
1595    }
1596}
1597
1598impl<'de> ::fidl_next::IntoNatural for WireCapability<'de> {
1599    type Natural = Capability;
1600}
1601
1602impl<'de> ::fidl_next::FromWireOption<WireOptionalCapability<'de>> for Capability {
1603    #[inline]
1604    fn from_wire_option(wire: WireOptionalCapability<'de>) -> ::core::option::Option<Self> {
1605        if let Some(inner) = wire.into_option() {
1606            Some(::fidl_next::FromWire::from_wire(inner))
1607        } else {
1608            None
1609        }
1610    }
1611}
1612
1613impl<'de> ::fidl_next::IntoNatural for WireOptionalCapability<'de> {
1614    type Natural = ::core::option::Option<Capability>;
1615}
1616
1617impl<'de> ::fidl_next::FromWireOption<WireOptionalCapability<'de>> for Box<Capability> {
1618    #[inline]
1619    fn from_wire_option(wire: WireOptionalCapability<'de>) -> ::core::option::Option<Self> {
1620        <Capability as ::fidl_next::FromWireOption<WireOptionalCapability<'de>>>::from_wire_option(
1621            wire,
1622        )
1623        .map(Box::new)
1624    }
1625}
1626
1627/// The wire type corresponding to [`Capability`].
1628#[repr(transparent)]
1629pub struct WireCapability<'de> {
1630    raw: ::fidl_next::RawWireUnion,
1631    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
1632}
1633
1634impl<'de> Drop for WireCapability<'de> {
1635    fn drop(&mut self) {
1636        match self.raw.ordinal() {
1637            1 => {
1638                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
1639            }
1640
1641            2 => {
1642                let _ =
1643                    unsafe { self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>() };
1644            }
1645
1646            3 => {
1647                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireData<'de>>() };
1648            }
1649
1650            4 => {
1651                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDictionaryRef>() };
1652            }
1653
1654            5 => {
1655                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireConnector>() };
1656            }
1657
1658            6 => {
1659                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirConnector>() };
1660            }
1661
1662            7 => {
1663                let _ = unsafe {
1664                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1665                        ::fidl_next_fuchsia_io::Directory,
1666                        ::fidl_next::fuchsia::WireChannel,
1667                    >>()
1668                };
1669            }
1670
1671            8 => {
1672                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirEntry>() };
1673            }
1674
1675            9 => {
1676                let _ = unsafe {
1677                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1678                        crate::ConnectorRouter,
1679                        ::fidl_next::fuchsia::WireChannel,
1680                    >>()
1681                };
1682            }
1683
1684            10 => {
1685                let _ = unsafe {
1686                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1687                        crate::DictionaryRouter,
1688                        ::fidl_next::fuchsia::WireChannel,
1689                    >>()
1690                };
1691            }
1692
1693            11 => {
1694                let _ = unsafe {
1695                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1696                        crate::DirEntryRouter,
1697                        ::fidl_next::fuchsia::WireChannel,
1698                    >>()
1699                };
1700            }
1701
1702            12 => {
1703                let _ = unsafe {
1704                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1705                };
1706            }
1707
1708            13 => {
1709                let _ = unsafe {
1710                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1711                        crate::DirConnectorRouter,
1712                        ::fidl_next::fuchsia::WireChannel,
1713                    >>()
1714                };
1715            }
1716
1717            _ => (),
1718        }
1719    }
1720}
1721
1722unsafe impl ::fidl_next::Wire for WireCapability<'static> {
1723    type Decoded<'de> = WireCapability<'de>;
1724
1725    #[inline]
1726    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
1727        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
1728        ::fidl_next::RawWireUnion::zero_padding(raw);
1729    }
1730}
1731
1732pub mod capability {
1733    pub enum Ref<'de> {
1734        Unit(&'de crate::WireUnit),
1735
1736        Handle(&'de ::fidl_next::fuchsia::WireHandle),
1737
1738        Data(&'de crate::WireData<'de>),
1739
1740        Dictionary(&'de crate::WireDictionaryRef),
1741
1742        Connector(&'de crate::WireConnector),
1743
1744        DirConnector(&'de crate::WireDirConnector),
1745
1746        Directory(
1747            &'de ::fidl_next::ClientEnd<
1748                ::fidl_next_fuchsia_io::Directory,
1749                ::fidl_next::fuchsia::WireChannel,
1750            >,
1751        ),
1752
1753        DirEntry(&'de crate::WireDirEntry),
1754
1755        ConnectorRouter(
1756            &'de ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
1757        ),
1758
1759        DictionaryRouter(
1760            &'de ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
1761        ),
1762
1763        DirEntryRouter(
1764            &'de ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
1765        ),
1766
1767        DataRouter(
1768            &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
1769        ),
1770
1771        DirConnectorRouter(
1772            &'de ::fidl_next::ClientEnd<
1773                crate::DirConnectorRouter,
1774                ::fidl_next::fuchsia::WireChannel,
1775            >,
1776        ),
1777
1778        UnknownOrdinal_(u64),
1779    }
1780}
1781
1782impl<'de> WireCapability<'de> {
1783    pub fn as_ref(&self) -> crate::capability::Ref<'_> {
1784        match self.raw.ordinal() {
1785            1 => crate::capability::Ref::Unit(unsafe {
1786                self.raw.get().deref_unchecked::<crate::WireUnit>()
1787            }),
1788
1789            2 => crate::capability::Ref::Handle(unsafe {
1790                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
1791            }),
1792
1793            3 => crate::capability::Ref::Data(unsafe {
1794                self.raw.get().deref_unchecked::<crate::WireData<'_>>()
1795            }),
1796
1797            4 => crate::capability::Ref::Dictionary(unsafe {
1798                self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
1799            }),
1800
1801            5 => crate::capability::Ref::Connector(unsafe {
1802                self.raw.get().deref_unchecked::<crate::WireConnector>()
1803            }),
1804
1805            6 => crate::capability::Ref::DirConnector(unsafe {
1806                self.raw.get().deref_unchecked::<crate::WireDirConnector>()
1807            }),
1808
1809            7 => crate::capability::Ref::Directory(unsafe {
1810                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1811                    ::fidl_next_fuchsia_io::Directory,
1812                    ::fidl_next::fuchsia::WireChannel,
1813                >>()
1814            }),
1815
1816            8 => crate::capability::Ref::DirEntry(unsafe {
1817                self.raw.get().deref_unchecked::<crate::WireDirEntry>()
1818            }),
1819
1820            9 => crate::capability::Ref::ConnectorRouter(unsafe {
1821                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1822                    crate::ConnectorRouter,
1823                    ::fidl_next::fuchsia::WireChannel,
1824                >>()
1825            }),
1826
1827            10 => crate::capability::Ref::DictionaryRouter(unsafe {
1828                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1829                    crate::DictionaryRouter,
1830                    ::fidl_next::fuchsia::WireChannel,
1831                >>()
1832            }),
1833
1834            11 => crate::capability::Ref::DirEntryRouter(unsafe {
1835                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>>()
1836            }),
1837
1838            12 => crate::capability::Ref::DataRouter(unsafe {
1839                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1840            }),
1841
1842            13 => crate::capability::Ref::DirConnectorRouter(unsafe {
1843                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
1844                    crate::DirConnectorRouter,
1845                    ::fidl_next::fuchsia::WireChannel,
1846                >>()
1847            }),
1848
1849            unknown => crate::capability::Ref::UnknownOrdinal_(unknown),
1850        }
1851    }
1852}
1853
1854unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapability<'static>
1855where
1856    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
1857    ___D: ::fidl_next::Decoder,
1858    ___D: ::fidl_next::fuchsia::HandleDecoder,
1859{
1860    fn decode(
1861        mut slot: ::fidl_next::Slot<'_, Self>,
1862        decoder: &mut ___D,
1863    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
1864        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
1865        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
1866            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
1867
1868            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
1869                raw, decoder,
1870            )?,
1871
1872            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
1873                raw, decoder,
1874            )?,
1875
1876            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDictionaryRef>(
1877                raw, decoder,
1878            )?,
1879
1880            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,
1881
1882            6 => {
1883                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirConnector>(raw, decoder)?
1884            }
1885
1886            7 => ::fidl_next::RawWireUnion::decode_as::<
1887                ___D,
1888                ::fidl_next::ClientEnd<
1889                    ::fidl_next_fuchsia_io::Directory,
1890                    ::fidl_next::fuchsia::WireChannel,
1891                >,
1892            >(raw, decoder)?,
1893
1894            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,
1895
1896            9 => ::fidl_next::RawWireUnion::decode_as::<
1897                ___D,
1898                ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
1899            >(raw, decoder)?,
1900
1901            10 => ::fidl_next::RawWireUnion::decode_as::<
1902                ___D,
1903                ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
1904            >(raw, decoder)?,
1905
1906            11 => ::fidl_next::RawWireUnion::decode_as::<
1907                ___D,
1908                ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
1909            >(raw, decoder)?,
1910
1911            12 => ::fidl_next::RawWireUnion::decode_as::<
1912                ___D,
1913                ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
1914            >(raw, decoder)?,
1915
1916            13 => ::fidl_next::RawWireUnion::decode_as::<
1917                ___D,
1918                ::fidl_next::ClientEnd<
1919                    crate::DirConnectorRouter,
1920                    ::fidl_next::fuchsia::WireChannel,
1921                >,
1922            >(raw, decoder)?,
1923
1924            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
1925        }
1926
1927        Ok(())
1928    }
1929}
1930
1931impl<'de> ::core::fmt::Debug for WireCapability<'de> {
1932    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1933        match self.raw.ordinal() {
1934            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
1935            2 => unsafe {
1936                self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
1937            },
1938            3 => unsafe { self.raw.get().deref_unchecked::<crate::WireData<'_>>().fmt(f) },
1939            4 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionaryRef>().fmt(f) },
1940            5 => unsafe { self.raw.get().deref_unchecked::<crate::WireConnector>().fmt(f) },
1941            6 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirConnector>().fmt(f) },
1942            7 => unsafe {
1943                self.raw
1944                    .get()
1945                    .deref_unchecked::<::fidl_next::ClientEnd<
1946                        ::fidl_next_fuchsia_io::Directory,
1947                        ::fidl_next::fuchsia::WireChannel,
1948                    >>()
1949                    .fmt(f)
1950            },
1951            8 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
1952            9 => unsafe {
1953                self.raw
1954                    .get()
1955                    .deref_unchecked::<::fidl_next::ClientEnd<
1956                        crate::ConnectorRouter,
1957                        ::fidl_next::fuchsia::WireChannel,
1958                    >>()
1959                    .fmt(f)
1960            },
1961            10 => unsafe {
1962                self.raw
1963                    .get()
1964                    .deref_unchecked::<::fidl_next::ClientEnd<
1965                        crate::DictionaryRouter,
1966                        ::fidl_next::fuchsia::WireChannel,
1967                    >>()
1968                    .fmt(f)
1969            },
1970            11 => unsafe {
1971                self.raw.get().deref_unchecked::<
1972                            ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>
1973                        >().fmt(f)
1974            },
1975            12 => unsafe {
1976                self.raw.get().deref_unchecked::<
1977                            ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
1978                        >().fmt(f)
1979            },
1980            13 => unsafe {
1981                self.raw
1982                    .get()
1983                    .deref_unchecked::<::fidl_next::ClientEnd<
1984                        crate::DirConnectorRouter,
1985                        ::fidl_next::fuchsia::WireChannel,
1986                    >>()
1987                    .fmt(f)
1988            },
1989            _ => unsafe { ::core::hint::unreachable_unchecked() },
1990        }
1991    }
1992}
1993
1994#[repr(transparent)]
1995pub struct WireOptionalCapability<'de> {
1996    raw: ::fidl_next::RawWireUnion,
1997    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
1998}
1999
2000unsafe impl ::fidl_next::Wire for WireOptionalCapability<'static> {
2001    type Decoded<'de> = WireOptionalCapability<'de>;
2002
2003    #[inline]
2004    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2005        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2006        ::fidl_next::RawWireUnion::zero_padding(raw);
2007    }
2008}
2009
2010impl<'de> WireOptionalCapability<'de> {
2011    pub fn is_some(&self) -> bool {
2012        self.raw.is_some()
2013    }
2014
2015    pub fn is_none(&self) -> bool {
2016        self.raw.is_none()
2017    }
2018
2019    pub fn as_ref(&self) -> ::core::option::Option<&WireCapability<'de>> {
2020        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
2021    }
2022
2023    pub fn into_option(self) -> ::core::option::Option<WireCapability<'de>> {
2024        if self.is_some() {
2025            Some(WireCapability { raw: self.raw, _phantom: ::core::marker::PhantomData })
2026        } else {
2027            None
2028        }
2029    }
2030}
2031
2032unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalCapability<'static>
2033where
2034    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2035    ___D: ::fidl_next::Decoder,
2036    ___D: ::fidl_next::fuchsia::HandleDecoder,
2037{
2038    fn decode(
2039        mut slot: ::fidl_next::Slot<'_, Self>,
2040        decoder: &mut ___D,
2041    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2042        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2043        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
2044            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
2045
2046            2 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
2047                raw, decoder,
2048            )?,
2049
2050            3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
2051                raw, decoder,
2052            )?,
2053
2054            4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDictionaryRef>(
2055                raw, decoder,
2056            )?,
2057
2058            5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireConnector>(raw, decoder)?,
2059
2060            6 => {
2061                ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirConnector>(raw, decoder)?
2062            }
2063
2064            7 => ::fidl_next::RawWireUnion::decode_as::<
2065                ___D,
2066                ::fidl_next::ClientEnd<
2067                    ::fidl_next_fuchsia_io::Directory,
2068                    ::fidl_next::fuchsia::WireChannel,
2069                >,
2070            >(raw, decoder)?,
2071
2072            8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireDirEntry>(raw, decoder)?,
2073
2074            9 => ::fidl_next::RawWireUnion::decode_as::<
2075                ___D,
2076                ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::WireChannel>,
2077            >(raw, decoder)?,
2078
2079            10 => ::fidl_next::RawWireUnion::decode_as::<
2080                ___D,
2081                ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::WireChannel>,
2082            >(raw, decoder)?,
2083
2084            11 => ::fidl_next::RawWireUnion::decode_as::<
2085                ___D,
2086                ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::WireChannel>,
2087            >(raw, decoder)?,
2088
2089            12 => ::fidl_next::RawWireUnion::decode_as::<
2090                ___D,
2091                ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
2092            >(raw, decoder)?,
2093
2094            13 => ::fidl_next::RawWireUnion::decode_as::<
2095                ___D,
2096                ::fidl_next::ClientEnd<
2097                    crate::DirConnectorRouter,
2098                    ::fidl_next::fuchsia::WireChannel,
2099                >,
2100            >(raw, decoder)?,
2101
2102            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
2103            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
2104        }
2105
2106        Ok(())
2107    }
2108}
2109
2110impl<'de> ::core::fmt::Debug for WireOptionalCapability<'de> {
2111    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2112        self.as_ref().fmt(f)
2113    }
2114}
2115
2116#[doc = " A client-assigned id of a [Capability] in a [CapabilityStore].\n\n The id is relative to the [CapabilityStore]. In the case where two\n [CapabilityStore]s have a capability / assigned to the same id, there is\n no relation between them\n"]
2117pub type CapabilityId = u64;
2118
2119/// The wire type corresponding to [`CapabilityId`].
2120pub type WireCapabilityId = ::fidl_next::WireU64;
2121
2122#[doc = " A client-assigned id of a new [Capability] in a [CapabilityStore]. Same as [CapabilityId],\n but used to distinguish output parameters in [CapabilityStore] methods.\n"]
2123pub type NewCapabilityId = u64;
2124
2125/// The wire type corresponding to [`NewCapabilityId`].
2126pub type WireNewCapabilityId = ::fidl_next::WireU64;
2127
2128#[derive(PartialEq, Clone, Debug)]
2129#[repr(C)]
2130pub struct CapabilityStoreDuplicateRequest {
2131    pub id: u64,
2132
2133    pub dest_id: u64,
2134}
2135
2136impl ::fidl_next::Encodable for CapabilityStoreDuplicateRequest {
2137    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2138        Self,
2139        WireCapabilityStoreDuplicateRequest,
2140    > = unsafe {
2141        ::fidl_next::CopyOptimization::enable_if(
2142            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
2143                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2144        )
2145    };
2146
2147    type Encoded = WireCapabilityStoreDuplicateRequest;
2148}
2149
2150unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest
2151where
2152    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2153{
2154    #[inline]
2155    fn encode(
2156        self,
2157        encoder_: &mut ___E,
2158        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2159    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2160        ::fidl_next::munge! {
2161            let Self::Encoded {
2162                id,
2163                dest_id,
2164
2165            } = out_;
2166        }
2167
2168        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2169
2170        ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
2171
2172        Ok(())
2173    }
2174}
2175
2176unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateRequest
2177where
2178    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2179{
2180    #[inline]
2181    fn encode_ref(
2182        &self,
2183        encoder_: &mut ___E,
2184        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2185    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2186        ::fidl_next::munge! {
2187            let Self::Encoded {
2188
2189                id,
2190                dest_id,
2191
2192            } = out_;
2193        }
2194
2195        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2196
2197        ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
2198
2199        Ok(())
2200    }
2201}
2202
2203impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateRequest {
2204    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDuplicateRequest>;
2205}
2206
2207unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateRequest
2208where
2209    ___E: ::fidl_next::Encoder + ?Sized,
2210    CapabilityStoreDuplicateRequest: ::fidl_next::Encode<___E>,
2211{
2212    #[inline]
2213    fn encode_option(
2214        this: ::core::option::Option<Self>,
2215        encoder: &mut ___E,
2216        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2217    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2218        if let Some(inner) = this {
2219            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2220            ::fidl_next::WireBox::encode_present(out);
2221        } else {
2222            ::fidl_next::WireBox::encode_absent(out);
2223        }
2224
2225        Ok(())
2226    }
2227}
2228
2229unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateRequest
2230where
2231    ___E: ::fidl_next::Encoder + ?Sized,
2232    CapabilityStoreDuplicateRequest: ::fidl_next::EncodeRef<___E>,
2233{
2234    #[inline]
2235    fn encode_option_ref(
2236        this: ::core::option::Option<&Self>,
2237        encoder: &mut ___E,
2238        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2239    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2240        if let Some(inner) = this {
2241            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2242            ::fidl_next::WireBox::encode_present(out);
2243        } else {
2244            ::fidl_next::WireBox::encode_absent(out);
2245        }
2246
2247        Ok(())
2248    }
2249}
2250
2251impl ::fidl_next::FromWire<WireCapabilityStoreDuplicateRequest>
2252    for CapabilityStoreDuplicateRequest
2253{
2254    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2255        WireCapabilityStoreDuplicateRequest,
2256        Self,
2257    > = unsafe {
2258        ::fidl_next::CopyOptimization::enable_if(
2259            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2260                .is_enabled()
2261                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2262                    .is_enabled(),
2263        )
2264    };
2265
2266    #[inline]
2267    fn from_wire(wire: WireCapabilityStoreDuplicateRequest) -> Self {
2268        Self {
2269            id: ::fidl_next::FromWire::from_wire(wire.id),
2270
2271            dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
2272        }
2273    }
2274}
2275
2276impl ::fidl_next::IntoNatural for WireCapabilityStoreDuplicateRequest {
2277    type Natural = CapabilityStoreDuplicateRequest;
2278}
2279
2280impl ::fidl_next::FromWireRef<WireCapabilityStoreDuplicateRequest>
2281    for CapabilityStoreDuplicateRequest
2282{
2283    #[inline]
2284    fn from_wire_ref(wire: &WireCapabilityStoreDuplicateRequest) -> Self {
2285        Self {
2286            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
2287
2288            dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
2289        }
2290    }
2291}
2292
2293/// The wire type corresponding to [`CapabilityStoreDuplicateRequest`].
2294#[derive(Clone, Debug)]
2295#[repr(C)]
2296pub struct WireCapabilityStoreDuplicateRequest {
2297    pub id: ::fidl_next::WireU64,
2298
2299    pub dest_id: ::fidl_next::WireU64,
2300}
2301static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreDuplicateRequest>(), 16);
2302static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreDuplicateRequest>(), 8);
2303
2304static_assertions::const_assert_eq!(
2305    std::mem::offset_of!(WireCapabilityStoreDuplicateRequest, id),
2306    0
2307);
2308
2309static_assertions::const_assert_eq!(
2310    std::mem::offset_of!(WireCapabilityStoreDuplicateRequest, dest_id),
2311    8
2312);
2313
2314unsafe impl ::fidl_next::Wire for WireCapabilityStoreDuplicateRequest {
2315    type Decoded<'de> = WireCapabilityStoreDuplicateRequest;
2316
2317    #[inline]
2318    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2319        ::fidl_next::munge! {
2320            let Self {
2321
2322                id,
2323                dest_id,
2324
2325            } = &mut *out_;
2326        }
2327
2328        ::fidl_next::Wire::zero_padding(id);
2329
2330        ::fidl_next::Wire::zero_padding(dest_id);
2331    }
2332}
2333
2334unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDuplicateRequest
2335where
2336    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2337{
2338    fn decode(
2339        slot_: ::fidl_next::Slot<'_, Self>,
2340        decoder_: &mut ___D,
2341    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2342        ::fidl_next::munge! {
2343            let Self {
2344
2345                mut id,
2346                mut dest_id,
2347
2348            } = slot_;
2349        }
2350
2351        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2352
2353        ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
2354
2355        Ok(())
2356    }
2357}
2358
2359pub type CapabilityStoreDuplicateResponse = ();
2360
2361/// The wire type corresponding to [`CapabilityStoreDuplicateResponse`].
2362pub type WireCapabilityStoreDuplicateResponse = ();
2363
2364#[doc = " Error returned from methods in [CapabilityStore].\n"]
2365#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2366#[repr(u32)]
2367pub enum CapabilityStoreError {
2368    IdNotFound = 1,
2369    IdAlreadyExists = 2,
2370    BadCapability = 3,
2371    WrongType = 4,
2372    NotDuplicatable = 5,
2373    ItemNotFound = 6,
2374    ItemAlreadyExists = 7,
2375    InvalidKey = 8,
2376    InvalidArgs = 9,
2377    UnknownOrdinal_(u32) = 10,
2378}
2379
2380impl ::fidl_next::Encodable for CapabilityStoreError {
2381    type Encoded = WireCapabilityStoreError;
2382}
2383impl ::std::convert::From<u32> for CapabilityStoreError {
2384    fn from(value: u32) -> Self {
2385        match value {
2386            1 => Self::IdNotFound,
2387            2 => Self::IdAlreadyExists,
2388            3 => Self::BadCapability,
2389            4 => Self::WrongType,
2390            5 => Self::NotDuplicatable,
2391            6 => Self::ItemNotFound,
2392            7 => Self::ItemAlreadyExists,
2393            8 => Self::InvalidKey,
2394            9 => Self::InvalidArgs,
2395
2396            _ => Self::UnknownOrdinal_(value),
2397        }
2398    }
2399}
2400
2401unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreError
2402where
2403    ___E: ?Sized,
2404{
2405    #[inline]
2406    fn encode(
2407        self,
2408        encoder: &mut ___E,
2409        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2410    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2411        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
2412    }
2413}
2414
2415unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreError
2416where
2417    ___E: ?Sized,
2418{
2419    #[inline]
2420    fn encode_ref(
2421        &self,
2422        encoder: &mut ___E,
2423        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2424    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2425        ::fidl_next::munge!(let WireCapabilityStoreError { value } = out);
2426        let _ = value.write(::fidl_next::WireU32::from(match *self {
2427            Self::IdNotFound => 1,
2428
2429            Self::IdAlreadyExists => 2,
2430
2431            Self::BadCapability => 3,
2432
2433            Self::WrongType => 4,
2434
2435            Self::NotDuplicatable => 5,
2436
2437            Self::ItemNotFound => 6,
2438
2439            Self::ItemAlreadyExists => 7,
2440
2441            Self::InvalidKey => 8,
2442
2443            Self::InvalidArgs => 9,
2444
2445            Self::UnknownOrdinal_(value) => value,
2446        }));
2447
2448        Ok(())
2449    }
2450}
2451
2452impl ::core::convert::From<WireCapabilityStoreError> for CapabilityStoreError {
2453    fn from(wire: WireCapabilityStoreError) -> Self {
2454        match u32::from(wire.value) {
2455            1 => Self::IdNotFound,
2456
2457            2 => Self::IdAlreadyExists,
2458
2459            3 => Self::BadCapability,
2460
2461            4 => Self::WrongType,
2462
2463            5 => Self::NotDuplicatable,
2464
2465            6 => Self::ItemNotFound,
2466
2467            7 => Self::ItemAlreadyExists,
2468
2469            8 => Self::InvalidKey,
2470
2471            9 => Self::InvalidArgs,
2472
2473            value => Self::UnknownOrdinal_(value),
2474        }
2475    }
2476}
2477
2478impl ::fidl_next::FromWire<WireCapabilityStoreError> for CapabilityStoreError {
2479    #[inline]
2480    fn from_wire(wire: WireCapabilityStoreError) -> Self {
2481        Self::from(wire)
2482    }
2483}
2484
2485impl ::fidl_next::IntoNatural for WireCapabilityStoreError {
2486    type Natural = CapabilityStoreError;
2487}
2488
2489impl ::fidl_next::FromWireRef<WireCapabilityStoreError> for CapabilityStoreError {
2490    #[inline]
2491    fn from_wire_ref(wire: &WireCapabilityStoreError) -> Self {
2492        Self::from(*wire)
2493    }
2494}
2495
2496/// The wire type corresponding to [`CapabilityStoreError`].
2497#[derive(Clone, Copy, Debug, PartialEq, Eq)]
2498#[repr(transparent)]
2499pub struct WireCapabilityStoreError {
2500    value: ::fidl_next::WireU32,
2501}
2502
2503unsafe impl ::fidl_next::Wire for WireCapabilityStoreError {
2504    type Decoded<'de> = Self;
2505
2506    #[inline]
2507    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2508        // Wire enums have no padding
2509    }
2510}
2511
2512impl WireCapabilityStoreError {
2513    pub const ID_NOT_FOUND: WireCapabilityStoreError =
2514        WireCapabilityStoreError { value: ::fidl_next::WireU32(1) };
2515
2516    pub const ID_ALREADY_EXISTS: WireCapabilityStoreError =
2517        WireCapabilityStoreError { value: ::fidl_next::WireU32(2) };
2518
2519    pub const BAD_CAPABILITY: WireCapabilityStoreError =
2520        WireCapabilityStoreError { value: ::fidl_next::WireU32(3) };
2521
2522    pub const WRONG_TYPE: WireCapabilityStoreError =
2523        WireCapabilityStoreError { value: ::fidl_next::WireU32(4) };
2524
2525    pub const NOT_DUPLICATABLE: WireCapabilityStoreError =
2526        WireCapabilityStoreError { value: ::fidl_next::WireU32(5) };
2527
2528    pub const ITEM_NOT_FOUND: WireCapabilityStoreError =
2529        WireCapabilityStoreError { value: ::fidl_next::WireU32(6) };
2530
2531    pub const ITEM_ALREADY_EXISTS: WireCapabilityStoreError =
2532        WireCapabilityStoreError { value: ::fidl_next::WireU32(7) };
2533
2534    pub const INVALID_KEY: WireCapabilityStoreError =
2535        WireCapabilityStoreError { value: ::fidl_next::WireU32(8) };
2536
2537    pub const INVALID_ARGS: WireCapabilityStoreError =
2538        WireCapabilityStoreError { value: ::fidl_next::WireU32(9) };
2539}
2540
2541unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreError
2542where
2543    ___D: ?Sized,
2544{
2545    fn decode(
2546        slot: ::fidl_next::Slot<'_, Self>,
2547        _: &mut ___D,
2548    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2549        Ok(())
2550    }
2551}
2552
2553impl ::core::convert::From<CapabilityStoreError> for WireCapabilityStoreError {
2554    fn from(natural: CapabilityStoreError) -> Self {
2555        match natural {
2556            CapabilityStoreError::IdNotFound => WireCapabilityStoreError::ID_NOT_FOUND,
2557
2558            CapabilityStoreError::IdAlreadyExists => WireCapabilityStoreError::ID_ALREADY_EXISTS,
2559
2560            CapabilityStoreError::BadCapability => WireCapabilityStoreError::BAD_CAPABILITY,
2561
2562            CapabilityStoreError::WrongType => WireCapabilityStoreError::WRONG_TYPE,
2563
2564            CapabilityStoreError::NotDuplicatable => WireCapabilityStoreError::NOT_DUPLICATABLE,
2565
2566            CapabilityStoreError::ItemNotFound => WireCapabilityStoreError::ITEM_NOT_FOUND,
2567
2568            CapabilityStoreError::ItemAlreadyExists => {
2569                WireCapabilityStoreError::ITEM_ALREADY_EXISTS
2570            }
2571
2572            CapabilityStoreError::InvalidKey => WireCapabilityStoreError::INVALID_KEY,
2573
2574            CapabilityStoreError::InvalidArgs => WireCapabilityStoreError::INVALID_ARGS,
2575
2576            CapabilityStoreError::UnknownOrdinal_(value) => {
2577                WireCapabilityStoreError { value: ::fidl_next::WireU32::from(value) }
2578            }
2579        }
2580    }
2581}
2582
2583#[derive(PartialEq, Clone, Debug)]
2584#[repr(C)]
2585pub struct CapabilityStoreDropRequest {
2586    pub id: u64,
2587}
2588
2589impl ::fidl_next::Encodable for CapabilityStoreDropRequest {
2590    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCapabilityStoreDropRequest> = unsafe {
2591        ::fidl_next::CopyOptimization::enable_if(
2592            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2593        )
2594    };
2595
2596    type Encoded = WireCapabilityStoreDropRequest;
2597}
2598
2599unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest
2600where
2601    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2602{
2603    #[inline]
2604    fn encode(
2605        self,
2606        encoder_: &mut ___E,
2607        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2608    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2609        ::fidl_next::munge! {
2610            let Self::Encoded {
2611                id,
2612
2613            } = out_;
2614        }
2615
2616        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2617
2618        Ok(())
2619    }
2620}
2621
2622unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropRequest
2623where
2624    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2625{
2626    #[inline]
2627    fn encode_ref(
2628        &self,
2629        encoder_: &mut ___E,
2630        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2631    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2632        ::fidl_next::munge! {
2633            let Self::Encoded {
2634
2635                id,
2636
2637            } = out_;
2638        }
2639
2640        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2641
2642        Ok(())
2643    }
2644}
2645
2646impl ::fidl_next::EncodableOption for CapabilityStoreDropRequest {
2647    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDropRequest>;
2648}
2649
2650unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropRequest
2651where
2652    ___E: ::fidl_next::Encoder + ?Sized,
2653    CapabilityStoreDropRequest: ::fidl_next::Encode<___E>,
2654{
2655    #[inline]
2656    fn encode_option(
2657        this: ::core::option::Option<Self>,
2658        encoder: &mut ___E,
2659        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2660    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2661        if let Some(inner) = this {
2662            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2663            ::fidl_next::WireBox::encode_present(out);
2664        } else {
2665            ::fidl_next::WireBox::encode_absent(out);
2666        }
2667
2668        Ok(())
2669    }
2670}
2671
2672unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropRequest
2673where
2674    ___E: ::fidl_next::Encoder + ?Sized,
2675    CapabilityStoreDropRequest: ::fidl_next::EncodeRef<___E>,
2676{
2677    #[inline]
2678    fn encode_option_ref(
2679        this: ::core::option::Option<&Self>,
2680        encoder: &mut ___E,
2681        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2682    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2683        if let Some(inner) = this {
2684            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2685            ::fidl_next::WireBox::encode_present(out);
2686        } else {
2687            ::fidl_next::WireBox::encode_absent(out);
2688        }
2689
2690        Ok(())
2691    }
2692}
2693
2694impl ::fidl_next::FromWire<WireCapabilityStoreDropRequest> for CapabilityStoreDropRequest {
2695    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCapabilityStoreDropRequest, Self> = unsafe {
2696        ::fidl_next::CopyOptimization::enable_if(
2697            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2698                .is_enabled(),
2699        )
2700    };
2701
2702    #[inline]
2703    fn from_wire(wire: WireCapabilityStoreDropRequest) -> Self {
2704        Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2705    }
2706}
2707
2708impl ::fidl_next::IntoNatural for WireCapabilityStoreDropRequest {
2709    type Natural = CapabilityStoreDropRequest;
2710}
2711
2712impl ::fidl_next::FromWireRef<WireCapabilityStoreDropRequest> for CapabilityStoreDropRequest {
2713    #[inline]
2714    fn from_wire_ref(wire: &WireCapabilityStoreDropRequest) -> Self {
2715        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2716    }
2717}
2718
2719/// The wire type corresponding to [`CapabilityStoreDropRequest`].
2720#[derive(Clone, Debug)]
2721#[repr(C)]
2722pub struct WireCapabilityStoreDropRequest {
2723    pub id: ::fidl_next::WireU64,
2724}
2725static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreDropRequest>(), 8);
2726static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreDropRequest>(), 8);
2727
2728static_assertions::const_assert_eq!(std::mem::offset_of!(WireCapabilityStoreDropRequest, id), 0);
2729
2730unsafe impl ::fidl_next::Wire for WireCapabilityStoreDropRequest {
2731    type Decoded<'de> = WireCapabilityStoreDropRequest;
2732
2733    #[inline]
2734    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2735        ::fidl_next::munge! {
2736            let Self {
2737
2738                id,
2739
2740            } = &mut *out_;
2741        }
2742
2743        ::fidl_next::Wire::zero_padding(id);
2744    }
2745}
2746
2747unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDropRequest
2748where
2749    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2750{
2751    fn decode(
2752        slot_: ::fidl_next::Slot<'_, Self>,
2753        decoder_: &mut ___D,
2754    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2755        ::fidl_next::munge! {
2756            let Self {
2757
2758                mut id,
2759
2760            } = slot_;
2761        }
2762
2763        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2764
2765        Ok(())
2766    }
2767}
2768
2769pub type CapabilityStoreDropResponse = ();
2770
2771/// The wire type corresponding to [`CapabilityStoreDropResponse`].
2772pub type WireCapabilityStoreDropResponse = ();
2773
2774#[derive(PartialEq, Clone, Debug)]
2775#[repr(C)]
2776pub struct CapabilityStoreExportRequest {
2777    pub id: u64,
2778}
2779
2780impl ::fidl_next::Encodable for CapabilityStoreExportRequest {
2781    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCapabilityStoreExportRequest> = unsafe {
2782        ::fidl_next::CopyOptimization::enable_if(
2783            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2784        )
2785    };
2786
2787    type Encoded = WireCapabilityStoreExportRequest;
2788}
2789
2790unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest
2791where
2792    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2793{
2794    #[inline]
2795    fn encode(
2796        self,
2797        encoder_: &mut ___E,
2798        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2799    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2800        ::fidl_next::munge! {
2801            let Self::Encoded {
2802                id,
2803
2804            } = out_;
2805        }
2806
2807        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2808
2809        Ok(())
2810    }
2811}
2812
2813unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreExportRequest
2814where
2815    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2816{
2817    #[inline]
2818    fn encode_ref(
2819        &self,
2820        encoder_: &mut ___E,
2821        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2822    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2823        ::fidl_next::munge! {
2824            let Self::Encoded {
2825
2826                id,
2827
2828            } = out_;
2829        }
2830
2831        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
2832
2833        Ok(())
2834    }
2835}
2836
2837impl ::fidl_next::EncodableOption for CapabilityStoreExportRequest {
2838    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreExportRequest>;
2839}
2840
2841unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportRequest
2842where
2843    ___E: ::fidl_next::Encoder + ?Sized,
2844    CapabilityStoreExportRequest: ::fidl_next::Encode<___E>,
2845{
2846    #[inline]
2847    fn encode_option(
2848        this: ::core::option::Option<Self>,
2849        encoder: &mut ___E,
2850        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2851    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2852        if let Some(inner) = this {
2853            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2854            ::fidl_next::WireBox::encode_present(out);
2855        } else {
2856            ::fidl_next::WireBox::encode_absent(out);
2857        }
2858
2859        Ok(())
2860    }
2861}
2862
2863unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreExportRequest
2864where
2865    ___E: ::fidl_next::Encoder + ?Sized,
2866    CapabilityStoreExportRequest: ::fidl_next::EncodeRef<___E>,
2867{
2868    #[inline]
2869    fn encode_option_ref(
2870        this: ::core::option::Option<&Self>,
2871        encoder: &mut ___E,
2872        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2873    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2874        if let Some(inner) = this {
2875            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2876            ::fidl_next::WireBox::encode_present(out);
2877        } else {
2878            ::fidl_next::WireBox::encode_absent(out);
2879        }
2880
2881        Ok(())
2882    }
2883}
2884
2885impl ::fidl_next::FromWire<WireCapabilityStoreExportRequest> for CapabilityStoreExportRequest {
2886    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCapabilityStoreExportRequest, Self> = unsafe {
2887        ::fidl_next::CopyOptimization::enable_if(
2888            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2889                .is_enabled(),
2890        )
2891    };
2892
2893    #[inline]
2894    fn from_wire(wire: WireCapabilityStoreExportRequest) -> Self {
2895        Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2896    }
2897}
2898
2899impl ::fidl_next::IntoNatural for WireCapabilityStoreExportRequest {
2900    type Natural = CapabilityStoreExportRequest;
2901}
2902
2903impl ::fidl_next::FromWireRef<WireCapabilityStoreExportRequest> for CapabilityStoreExportRequest {
2904    #[inline]
2905    fn from_wire_ref(wire: &WireCapabilityStoreExportRequest) -> Self {
2906        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2907    }
2908}
2909
2910/// The wire type corresponding to [`CapabilityStoreExportRequest`].
2911#[derive(Clone, Debug)]
2912#[repr(C)]
2913pub struct WireCapabilityStoreExportRequest {
2914    pub id: ::fidl_next::WireU64,
2915}
2916static_assertions::const_assert_eq!(std::mem::size_of::<WireCapabilityStoreExportRequest>(), 8);
2917static_assertions::const_assert_eq!(std::mem::align_of::<WireCapabilityStoreExportRequest>(), 8);
2918
2919static_assertions::const_assert_eq!(std::mem::offset_of!(WireCapabilityStoreExportRequest, id), 0);
2920
2921unsafe impl ::fidl_next::Wire for WireCapabilityStoreExportRequest {
2922    type Decoded<'de> = WireCapabilityStoreExportRequest;
2923
2924    #[inline]
2925    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2926        ::fidl_next::munge! {
2927            let Self {
2928
2929                id,
2930
2931            } = &mut *out_;
2932        }
2933
2934        ::fidl_next::Wire::zero_padding(id);
2935    }
2936}
2937
2938unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportRequest
2939where
2940    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2941{
2942    fn decode(
2943        slot_: ::fidl_next::Slot<'_, Self>,
2944        decoder_: &mut ___D,
2945    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2946        ::fidl_next::munge! {
2947            let Self {
2948
2949                mut id,
2950
2951            } = slot_;
2952        }
2953
2954        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
2955
2956        Ok(())
2957    }
2958}
2959
2960pub type CapabilityStoreImportResponse = ();
2961
2962/// The wire type corresponding to [`CapabilityStoreImportResponse`].
2963pub type WireCapabilityStoreImportResponse = ();
2964
2965#[derive(PartialEq, Debug)]
2966pub struct CapabilityStoreConnectorCreateRequest {
2967    pub id: u64,
2968
2969    pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
2970}
2971
2972impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest {
2973    type Encoded = WireCapabilityStoreConnectorCreateRequest;
2974}
2975
2976unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateRequest
2977where
2978    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2979    ___E: ::fidl_next::fuchsia::HandleEncoder,
2980{
2981    #[inline]
2982    fn encode(
2983        self,
2984        encoder_: &mut ___E,
2985        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2986    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2987        ::fidl_next::munge! {
2988            let Self::Encoded {
2989                id,
2990                receiver,
2991
2992            } = out_;
2993        }
2994
2995        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
2996
2997        ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
2998
2999        Ok(())
3000    }
3001}
3002
3003impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateRequest {
3004    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreConnectorCreateRequest>;
3005}
3006
3007unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateRequest
3008where
3009    ___E: ::fidl_next::Encoder + ?Sized,
3010    CapabilityStoreConnectorCreateRequest: ::fidl_next::Encode<___E>,
3011{
3012    #[inline]
3013    fn encode_option(
3014        this: ::core::option::Option<Self>,
3015        encoder: &mut ___E,
3016        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3017    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3018        if let Some(inner) = this {
3019            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3020            ::fidl_next::WireBox::encode_present(out);
3021        } else {
3022            ::fidl_next::WireBox::encode_absent(out);
3023        }
3024
3025        Ok(())
3026    }
3027}
3028
3029impl ::fidl_next::FromWire<WireCapabilityStoreConnectorCreateRequest>
3030    for CapabilityStoreConnectorCreateRequest
3031{
3032    #[inline]
3033    fn from_wire(wire: WireCapabilityStoreConnectorCreateRequest) -> Self {
3034        Self {
3035            id: ::fidl_next::FromWire::from_wire(wire.id),
3036
3037            receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
3038        }
3039    }
3040}
3041
3042impl ::fidl_next::IntoNatural for WireCapabilityStoreConnectorCreateRequest {
3043    type Natural = CapabilityStoreConnectorCreateRequest;
3044}
3045
3046/// The wire type corresponding to [`CapabilityStoreConnectorCreateRequest`].
3047#[derive(Debug)]
3048#[repr(C)]
3049pub struct WireCapabilityStoreConnectorCreateRequest {
3050    pub id: ::fidl_next::WireU64,
3051
3052    pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
3053}
3054static_assertions::const_assert_eq!(
3055    std::mem::size_of::<WireCapabilityStoreConnectorCreateRequest>(),
3056    16
3057);
3058static_assertions::const_assert_eq!(
3059    std::mem::align_of::<WireCapabilityStoreConnectorCreateRequest>(),
3060    8
3061);
3062
3063static_assertions::const_assert_eq!(
3064    std::mem::offset_of!(WireCapabilityStoreConnectorCreateRequest, id),
3065    0
3066);
3067
3068static_assertions::const_assert_eq!(
3069    std::mem::offset_of!(WireCapabilityStoreConnectorCreateRequest, receiver),
3070    8
3071);
3072
3073unsafe impl ::fidl_next::Wire for WireCapabilityStoreConnectorCreateRequest {
3074    type Decoded<'de> = WireCapabilityStoreConnectorCreateRequest;
3075
3076    #[inline]
3077    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3078        ::fidl_next::munge! {
3079            let Self {
3080
3081                id,
3082                receiver,
3083
3084            } = &mut *out_;
3085        }
3086
3087        ::fidl_next::Wire::zero_padding(id);
3088
3089        ::fidl_next::Wire::zero_padding(receiver);
3090
3091        unsafe {
3092            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3093        }
3094    }
3095}
3096
3097unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorCreateRequest
3098where
3099    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3100    ___D: ::fidl_next::fuchsia::HandleDecoder,
3101{
3102    fn decode(
3103        slot_: ::fidl_next::Slot<'_, Self>,
3104        decoder_: &mut ___D,
3105    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3106        ::fidl_next::munge! {
3107            let Self {
3108
3109                mut id,
3110                mut receiver,
3111
3112            } = slot_;
3113        }
3114
3115        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3116
3117        ::fidl_next::Decode::decode(receiver.as_mut(), decoder_)?;
3118
3119        Ok(())
3120    }
3121}
3122
3123pub type CapabilityStoreConnectorCreateResponse = ();
3124
3125/// The wire type corresponding to [`CapabilityStoreConnectorCreateResponse`].
3126pub type WireCapabilityStoreConnectorCreateResponse = ();
3127
3128#[derive(PartialEq, Debug)]
3129pub struct CapabilityStoreConnectorOpenRequest {
3130    pub id: u64,
3131
3132    pub server_end: ::fidl_next::fuchsia::zx::Channel,
3133}
3134
3135impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest {
3136    type Encoded = WireCapabilityStoreConnectorOpenRequest;
3137}
3138
3139unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest
3140where
3141    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3142    ___E: ::fidl_next::fuchsia::HandleEncoder,
3143{
3144    #[inline]
3145    fn encode(
3146        self,
3147        encoder_: &mut ___E,
3148        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3149    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3150        ::fidl_next::munge! {
3151            let Self::Encoded {
3152                id,
3153                server_end,
3154
3155            } = out_;
3156        }
3157
3158        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3159
3160        ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
3161
3162        Ok(())
3163    }
3164}
3165
3166impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenRequest {
3167    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreConnectorOpenRequest>;
3168}
3169
3170unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenRequest
3171where
3172    ___E: ::fidl_next::Encoder + ?Sized,
3173    CapabilityStoreConnectorOpenRequest: ::fidl_next::Encode<___E>,
3174{
3175    #[inline]
3176    fn encode_option(
3177        this: ::core::option::Option<Self>,
3178        encoder: &mut ___E,
3179        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3180    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3181        if let Some(inner) = this {
3182            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3183            ::fidl_next::WireBox::encode_present(out);
3184        } else {
3185            ::fidl_next::WireBox::encode_absent(out);
3186        }
3187
3188        Ok(())
3189    }
3190}
3191
3192impl ::fidl_next::FromWire<WireCapabilityStoreConnectorOpenRequest>
3193    for CapabilityStoreConnectorOpenRequest
3194{
3195    #[inline]
3196    fn from_wire(wire: WireCapabilityStoreConnectorOpenRequest) -> Self {
3197        Self {
3198            id: ::fidl_next::FromWire::from_wire(wire.id),
3199
3200            server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3201        }
3202    }
3203}
3204
3205impl ::fidl_next::IntoNatural for WireCapabilityStoreConnectorOpenRequest {
3206    type Natural = CapabilityStoreConnectorOpenRequest;
3207}
3208
3209/// The wire type corresponding to [`CapabilityStoreConnectorOpenRequest`].
3210#[derive(Debug)]
3211#[repr(C)]
3212pub struct WireCapabilityStoreConnectorOpenRequest {
3213    pub id: ::fidl_next::WireU64,
3214
3215    pub server_end: ::fidl_next::fuchsia::WireChannel,
3216}
3217static_assertions::const_assert_eq!(
3218    std::mem::size_of::<WireCapabilityStoreConnectorOpenRequest>(),
3219    16
3220);
3221static_assertions::const_assert_eq!(
3222    std::mem::align_of::<WireCapabilityStoreConnectorOpenRequest>(),
3223    8
3224);
3225
3226static_assertions::const_assert_eq!(
3227    std::mem::offset_of!(WireCapabilityStoreConnectorOpenRequest, id),
3228    0
3229);
3230
3231static_assertions::const_assert_eq!(
3232    std::mem::offset_of!(WireCapabilityStoreConnectorOpenRequest, server_end),
3233    8
3234);
3235
3236unsafe impl ::fidl_next::Wire for WireCapabilityStoreConnectorOpenRequest {
3237    type Decoded<'de> = WireCapabilityStoreConnectorOpenRequest;
3238
3239    #[inline]
3240    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3241        ::fidl_next::munge! {
3242            let Self {
3243
3244                id,
3245                server_end,
3246
3247            } = &mut *out_;
3248        }
3249
3250        ::fidl_next::Wire::zero_padding(id);
3251
3252        ::fidl_next::Wire::zero_padding(server_end);
3253
3254        unsafe {
3255            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3256        }
3257    }
3258}
3259
3260unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreConnectorOpenRequest
3261where
3262    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3263    ___D: ::fidl_next::fuchsia::HandleDecoder,
3264{
3265    fn decode(
3266        slot_: ::fidl_next::Slot<'_, Self>,
3267        decoder_: &mut ___D,
3268    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3269        ::fidl_next::munge! {
3270            let Self {
3271
3272                mut id,
3273                mut server_end,
3274
3275            } = slot_;
3276        }
3277
3278        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3279
3280        ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
3281
3282        Ok(())
3283    }
3284}
3285
3286pub type CapabilityStoreConnectorOpenResponse = ();
3287
3288/// The wire type corresponding to [`CapabilityStoreConnectorOpenResponse`].
3289pub type WireCapabilityStoreConnectorOpenResponse = ();
3290
3291pub type CapabilityStoreDirConnectorCreateResponse = ();
3292
3293/// The wire type corresponding to [`CapabilityStoreDirConnectorCreateResponse`].
3294pub type WireCapabilityStoreDirConnectorCreateResponse = ();
3295
3296pub type CapabilityStoreDirConnectorOpenResponse = ();
3297
3298/// The wire type corresponding to [`CapabilityStoreDirConnectorOpenResponse`].
3299pub type WireCapabilityStoreDirConnectorOpenResponse = ();
3300
3301#[derive(PartialEq, Clone, Debug)]
3302#[repr(C)]
3303pub struct CapabilityStoreDictionaryCreateRequest {
3304    pub id: u64,
3305}
3306
3307impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest {
3308    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3309        Self,
3310        WireCapabilityStoreDictionaryCreateRequest,
3311    > = unsafe {
3312        ::fidl_next::CopyOptimization::enable_if(
3313            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
3314        )
3315    };
3316
3317    type Encoded = WireCapabilityStoreDictionaryCreateRequest;
3318}
3319
3320unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest
3321where
3322    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3323{
3324    #[inline]
3325    fn encode(
3326        self,
3327        encoder_: &mut ___E,
3328        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3329    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3330        ::fidl_next::munge! {
3331            let Self::Encoded {
3332                id,
3333
3334            } = out_;
3335        }
3336
3337        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3338
3339        Ok(())
3340    }
3341}
3342
3343unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateRequest
3344where
3345    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3346{
3347    #[inline]
3348    fn encode_ref(
3349        &self,
3350        encoder_: &mut ___E,
3351        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3352    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3353        ::fidl_next::munge! {
3354            let Self::Encoded {
3355
3356                id,
3357
3358            } = out_;
3359        }
3360
3361        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
3362
3363        Ok(())
3364    }
3365}
3366
3367impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateRequest {
3368    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryCreateRequest>;
3369}
3370
3371unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateRequest
3372where
3373    ___E: ::fidl_next::Encoder + ?Sized,
3374    CapabilityStoreDictionaryCreateRequest: ::fidl_next::Encode<___E>,
3375{
3376    #[inline]
3377    fn encode_option(
3378        this: ::core::option::Option<Self>,
3379        encoder: &mut ___E,
3380        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3381    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3382        if let Some(inner) = this {
3383            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3384            ::fidl_next::WireBox::encode_present(out);
3385        } else {
3386            ::fidl_next::WireBox::encode_absent(out);
3387        }
3388
3389        Ok(())
3390    }
3391}
3392
3393unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateRequest
3394where
3395    ___E: ::fidl_next::Encoder + ?Sized,
3396    CapabilityStoreDictionaryCreateRequest: ::fidl_next::EncodeRef<___E>,
3397{
3398    #[inline]
3399    fn encode_option_ref(
3400        this: ::core::option::Option<&Self>,
3401        encoder: &mut ___E,
3402        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3403    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3404        if let Some(inner) = this {
3405            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3406            ::fidl_next::WireBox::encode_present(out);
3407        } else {
3408            ::fidl_next::WireBox::encode_absent(out);
3409        }
3410
3411        Ok(())
3412    }
3413}
3414
3415impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryCreateRequest>
3416    for CapabilityStoreDictionaryCreateRequest
3417{
3418    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3419        WireCapabilityStoreDictionaryCreateRequest,
3420        Self,
3421    > = unsafe {
3422        ::fidl_next::CopyOptimization::enable_if(
3423            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
3424                .is_enabled(),
3425        )
3426    };
3427
3428    #[inline]
3429    fn from_wire(wire: WireCapabilityStoreDictionaryCreateRequest) -> Self {
3430        Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
3431    }
3432}
3433
3434impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryCreateRequest {
3435    type Natural = CapabilityStoreDictionaryCreateRequest;
3436}
3437
3438impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCreateRequest>
3439    for CapabilityStoreDictionaryCreateRequest
3440{
3441    #[inline]
3442    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCreateRequest) -> Self {
3443        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
3444    }
3445}
3446
3447/// The wire type corresponding to [`CapabilityStoreDictionaryCreateRequest`].
3448#[derive(Clone, Debug)]
3449#[repr(C)]
3450pub struct WireCapabilityStoreDictionaryCreateRequest {
3451    pub id: ::fidl_next::WireU64,
3452}
3453static_assertions::const_assert_eq!(
3454    std::mem::size_of::<WireCapabilityStoreDictionaryCreateRequest>(),
3455    8
3456);
3457static_assertions::const_assert_eq!(
3458    std::mem::align_of::<WireCapabilityStoreDictionaryCreateRequest>(),
3459    8
3460);
3461
3462static_assertions::const_assert_eq!(
3463    std::mem::offset_of!(WireCapabilityStoreDictionaryCreateRequest, id),
3464    0
3465);
3466
3467unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryCreateRequest {
3468    type Decoded<'de> = WireCapabilityStoreDictionaryCreateRequest;
3469
3470    #[inline]
3471    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3472        ::fidl_next::munge! {
3473            let Self {
3474
3475                id,
3476
3477            } = &mut *out_;
3478        }
3479
3480        ::fidl_next::Wire::zero_padding(id);
3481    }
3482}
3483
3484unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCreateRequest
3485where
3486    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3487{
3488    fn decode(
3489        slot_: ::fidl_next::Slot<'_, Self>,
3490        decoder_: &mut ___D,
3491    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3492        ::fidl_next::munge! {
3493            let Self {
3494
3495                mut id,
3496
3497            } = slot_;
3498        }
3499
3500        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3501
3502        Ok(())
3503    }
3504}
3505
3506pub type CapabilityStoreDictionaryCreateResponse = ();
3507
3508/// The wire type corresponding to [`CapabilityStoreDictionaryCreateResponse`].
3509pub type WireCapabilityStoreDictionaryCreateResponse = ();
3510
3511#[derive(PartialEq, Debug)]
3512pub struct CapabilityStoreDictionaryLegacyImportRequest {
3513    pub id: u64,
3514
3515    pub client_end: ::fidl_next::fuchsia::zx::Channel,
3516}
3517
3518impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest {
3519    type Encoded = WireCapabilityStoreDictionaryLegacyImportRequest;
3520}
3521
3522unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportRequest
3523where
3524    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3525    ___E: ::fidl_next::fuchsia::HandleEncoder,
3526{
3527    #[inline]
3528    fn encode(
3529        self,
3530        encoder_: &mut ___E,
3531        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3532    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3533        ::fidl_next::munge! {
3534            let Self::Encoded {
3535                id,
3536                client_end,
3537
3538            } = out_;
3539        }
3540
3541        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3542
3543        ::fidl_next::Encode::encode(self.client_end, encoder_, client_end)?;
3544
3545        Ok(())
3546    }
3547}
3548
3549impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportRequest {
3550    type EncodedOption =
3551        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryLegacyImportRequest>;
3552}
3553
3554unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportRequest
3555where
3556    ___E: ::fidl_next::Encoder + ?Sized,
3557    CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Encode<___E>,
3558{
3559    #[inline]
3560    fn encode_option(
3561        this: ::core::option::Option<Self>,
3562        encoder: &mut ___E,
3563        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3564    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3565        if let Some(inner) = this {
3566            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3567            ::fidl_next::WireBox::encode_present(out);
3568        } else {
3569            ::fidl_next::WireBox::encode_absent(out);
3570        }
3571
3572        Ok(())
3573    }
3574}
3575
3576impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyImportRequest>
3577    for CapabilityStoreDictionaryLegacyImportRequest
3578{
3579    #[inline]
3580    fn from_wire(wire: WireCapabilityStoreDictionaryLegacyImportRequest) -> Self {
3581        Self {
3582            id: ::fidl_next::FromWire::from_wire(wire.id),
3583
3584            client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
3585        }
3586    }
3587}
3588
3589impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryLegacyImportRequest {
3590    type Natural = CapabilityStoreDictionaryLegacyImportRequest;
3591}
3592
3593/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportRequest`].
3594#[derive(Debug)]
3595#[repr(C)]
3596pub struct WireCapabilityStoreDictionaryLegacyImportRequest {
3597    pub id: ::fidl_next::WireU64,
3598
3599    pub client_end: ::fidl_next::fuchsia::WireChannel,
3600}
3601static_assertions::const_assert_eq!(
3602    std::mem::size_of::<WireCapabilityStoreDictionaryLegacyImportRequest>(),
3603    16
3604);
3605static_assertions::const_assert_eq!(
3606    std::mem::align_of::<WireCapabilityStoreDictionaryLegacyImportRequest>(),
3607    8
3608);
3609
3610static_assertions::const_assert_eq!(
3611    std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyImportRequest, id),
3612    0
3613);
3614
3615static_assertions::const_assert_eq!(
3616    std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyImportRequest, client_end),
3617    8
3618);
3619
3620unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryLegacyImportRequest {
3621    type Decoded<'de> = WireCapabilityStoreDictionaryLegacyImportRequest;
3622
3623    #[inline]
3624    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3625        ::fidl_next::munge! {
3626            let Self {
3627
3628                id,
3629                client_end,
3630
3631            } = &mut *out_;
3632        }
3633
3634        ::fidl_next::Wire::zero_padding(id);
3635
3636        ::fidl_next::Wire::zero_padding(client_end);
3637
3638        unsafe {
3639            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3640        }
3641    }
3642}
3643
3644unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyImportRequest
3645where
3646    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3647    ___D: ::fidl_next::fuchsia::HandleDecoder,
3648{
3649    fn decode(
3650        slot_: ::fidl_next::Slot<'_, Self>,
3651        decoder_: &mut ___D,
3652    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3653        ::fidl_next::munge! {
3654            let Self {
3655
3656                mut id,
3657                mut client_end,
3658
3659            } = slot_;
3660        }
3661
3662        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3663
3664        ::fidl_next::Decode::decode(client_end.as_mut(), decoder_)?;
3665
3666        Ok(())
3667    }
3668}
3669
3670pub type CapabilityStoreDictionaryLegacyImportResponse = ();
3671
3672/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportResponse`].
3673pub type WireCapabilityStoreDictionaryLegacyImportResponse = ();
3674
3675#[derive(PartialEq, Debug)]
3676pub struct CapabilityStoreDictionaryLegacyExportRequest {
3677    pub id: u64,
3678
3679    pub server_end: ::fidl_next::fuchsia::zx::Channel,
3680}
3681
3682impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest {
3683    type Encoded = WireCapabilityStoreDictionaryLegacyExportRequest;
3684}
3685
3686unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportRequest
3687where
3688    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3689    ___E: ::fidl_next::fuchsia::HandleEncoder,
3690{
3691    #[inline]
3692    fn encode(
3693        self,
3694        encoder_: &mut ___E,
3695        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3696    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3697        ::fidl_next::munge! {
3698            let Self::Encoded {
3699                id,
3700                server_end,
3701
3702            } = out_;
3703        }
3704
3705        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
3706
3707        ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
3708
3709        Ok(())
3710    }
3711}
3712
3713impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportRequest {
3714    type EncodedOption =
3715        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryLegacyExportRequest>;
3716}
3717
3718unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportRequest
3719where
3720    ___E: ::fidl_next::Encoder + ?Sized,
3721    CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Encode<___E>,
3722{
3723    #[inline]
3724    fn encode_option(
3725        this: ::core::option::Option<Self>,
3726        encoder: &mut ___E,
3727        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3728    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3729        if let Some(inner) = this {
3730            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3731            ::fidl_next::WireBox::encode_present(out);
3732        } else {
3733            ::fidl_next::WireBox::encode_absent(out);
3734        }
3735
3736        Ok(())
3737    }
3738}
3739
3740impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryLegacyExportRequest>
3741    for CapabilityStoreDictionaryLegacyExportRequest
3742{
3743    #[inline]
3744    fn from_wire(wire: WireCapabilityStoreDictionaryLegacyExportRequest) -> Self {
3745        Self {
3746            id: ::fidl_next::FromWire::from_wire(wire.id),
3747
3748            server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3749        }
3750    }
3751}
3752
3753impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryLegacyExportRequest {
3754    type Natural = CapabilityStoreDictionaryLegacyExportRequest;
3755}
3756
3757/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportRequest`].
3758#[derive(Debug)]
3759#[repr(C)]
3760pub struct WireCapabilityStoreDictionaryLegacyExportRequest {
3761    pub id: ::fidl_next::WireU64,
3762
3763    pub server_end: ::fidl_next::fuchsia::WireChannel,
3764}
3765static_assertions::const_assert_eq!(
3766    std::mem::size_of::<WireCapabilityStoreDictionaryLegacyExportRequest>(),
3767    16
3768);
3769static_assertions::const_assert_eq!(
3770    std::mem::align_of::<WireCapabilityStoreDictionaryLegacyExportRequest>(),
3771    8
3772);
3773
3774static_assertions::const_assert_eq!(
3775    std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyExportRequest, id),
3776    0
3777);
3778
3779static_assertions::const_assert_eq!(
3780    std::mem::offset_of!(WireCapabilityStoreDictionaryLegacyExportRequest, server_end),
3781    8
3782);
3783
3784unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryLegacyExportRequest {
3785    type Decoded<'de> = WireCapabilityStoreDictionaryLegacyExportRequest;
3786
3787    #[inline]
3788    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3789        ::fidl_next::munge! {
3790            let Self {
3791
3792                id,
3793                server_end,
3794
3795            } = &mut *out_;
3796        }
3797
3798        ::fidl_next::Wire::zero_padding(id);
3799
3800        ::fidl_next::Wire::zero_padding(server_end);
3801
3802        unsafe {
3803            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
3804        }
3805    }
3806}
3807
3808unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryLegacyExportRequest
3809where
3810    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3811    ___D: ::fidl_next::fuchsia::HandleDecoder,
3812{
3813    fn decode(
3814        slot_: ::fidl_next::Slot<'_, Self>,
3815        decoder_: &mut ___D,
3816    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3817        ::fidl_next::munge! {
3818            let Self {
3819
3820                mut id,
3821                mut server_end,
3822
3823            } = slot_;
3824        }
3825
3826        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
3827
3828        ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
3829
3830        Ok(())
3831    }
3832}
3833
3834pub type CapabilityStoreDictionaryLegacyExportResponse = ();
3835
3836/// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportResponse`].
3837pub type WireCapabilityStoreDictionaryLegacyExportResponse = ();
3838
3839#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
3840pub const MAX_NAME_LENGTH: u64 = 255 as u64;
3841
3842#[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
3843pub type DictionaryKey = ::std::string::String;
3844
3845/// The wire type corresponding to [`DictionaryKey`].
3846pub type WireDictionaryKey<'de> = ::fidl_next::WireString<'de>;
3847
3848#[doc = " A key-value pair in a [`DictionaryRef`].\n"]
3849#[derive(PartialEq, Clone, Debug)]
3850pub struct DictionaryItem {
3851    pub key: ::std::string::String,
3852
3853    pub value: u64,
3854}
3855
3856impl ::fidl_next::Encodable for DictionaryItem {
3857    type Encoded = WireDictionaryItem<'static>;
3858}
3859
3860unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryItem
3861where
3862    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3863    ___E: ::fidl_next::Encoder,
3864{
3865    #[inline]
3866    fn encode(
3867        self,
3868        encoder_: &mut ___E,
3869        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3870    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3871        ::fidl_next::munge! {
3872            let Self::Encoded {
3873                key,
3874                value,
3875
3876            } = out_;
3877        }
3878
3879        ::fidl_next::Encode::encode(self.key, encoder_, key)?;
3880
3881        ::fidl_next::Encode::encode(self.value, encoder_, value)?;
3882
3883        Ok(())
3884    }
3885}
3886
3887unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryItem
3888where
3889    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3890    ___E: ::fidl_next::Encoder,
3891{
3892    #[inline]
3893    fn encode_ref(
3894        &self,
3895        encoder_: &mut ___E,
3896        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3897    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3898        ::fidl_next::munge! {
3899            let Self::Encoded {
3900
3901                key,
3902                value,
3903
3904            } = out_;
3905        }
3906
3907        ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
3908
3909        ::fidl_next::EncodeRef::encode_ref(&self.value, encoder_, value)?;
3910
3911        Ok(())
3912    }
3913}
3914
3915impl ::fidl_next::EncodableOption for DictionaryItem {
3916    type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryItem<'static>>;
3917}
3918
3919unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryItem
3920where
3921    ___E: ::fidl_next::Encoder + ?Sized,
3922    DictionaryItem: ::fidl_next::Encode<___E>,
3923{
3924    #[inline]
3925    fn encode_option(
3926        this: ::core::option::Option<Self>,
3927        encoder: &mut ___E,
3928        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3929    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3930        if let Some(inner) = this {
3931            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3932            ::fidl_next::WireBox::encode_present(out);
3933        } else {
3934            ::fidl_next::WireBox::encode_absent(out);
3935        }
3936
3937        Ok(())
3938    }
3939}
3940
3941unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryItem
3942where
3943    ___E: ::fidl_next::Encoder + ?Sized,
3944    DictionaryItem: ::fidl_next::EncodeRef<___E>,
3945{
3946    #[inline]
3947    fn encode_option_ref(
3948        this: ::core::option::Option<&Self>,
3949        encoder: &mut ___E,
3950        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3951    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3952        if let Some(inner) = this {
3953            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3954            ::fidl_next::WireBox::encode_present(out);
3955        } else {
3956            ::fidl_next::WireBox::encode_absent(out);
3957        }
3958
3959        Ok(())
3960    }
3961}
3962
3963impl<'de> ::fidl_next::FromWire<WireDictionaryItem<'de>> for DictionaryItem {
3964    #[inline]
3965    fn from_wire(wire: WireDictionaryItem<'de>) -> Self {
3966        Self {
3967            key: ::fidl_next::FromWire::from_wire(wire.key),
3968
3969            value: ::fidl_next::FromWire::from_wire(wire.value),
3970        }
3971    }
3972}
3973
3974impl<'de> ::fidl_next::IntoNatural for WireDictionaryItem<'de> {
3975    type Natural = DictionaryItem;
3976}
3977
3978impl<'de> ::fidl_next::FromWireRef<WireDictionaryItem<'de>> for DictionaryItem {
3979    #[inline]
3980    fn from_wire_ref(wire: &WireDictionaryItem<'de>) -> Self {
3981        Self {
3982            key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3983
3984            value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
3985        }
3986    }
3987}
3988
3989/// The wire type corresponding to [`DictionaryItem`].
3990#[derive(Debug)]
3991#[repr(C)]
3992pub struct WireDictionaryItem<'de> {
3993    pub key: ::fidl_next::WireString<'de>,
3994
3995    pub value: ::fidl_next::WireU64,
3996}
3997static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryItem<'_>>(), 24);
3998static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryItem<'_>>(), 8);
3999
4000static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryItem<'_>, key), 0);
4001
4002static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryItem<'_>, value), 16);
4003
4004unsafe impl ::fidl_next::Wire for WireDictionaryItem<'static> {
4005    type Decoded<'de> = WireDictionaryItem<'de>;
4006
4007    #[inline]
4008    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4009        ::fidl_next::munge! {
4010            let Self {
4011
4012                key,
4013                value,
4014
4015            } = &mut *out_;
4016        }
4017
4018        ::fidl_next::Wire::zero_padding(key);
4019
4020        ::fidl_next::Wire::zero_padding(value);
4021    }
4022}
4023
4024unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryItem<'static>
4025where
4026    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4027    ___D: ::fidl_next::Decoder,
4028{
4029    fn decode(
4030        slot_: ::fidl_next::Slot<'_, Self>,
4031        decoder_: &mut ___D,
4032    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4033        ::fidl_next::munge! {
4034            let Self {
4035
4036                mut key,
4037                mut value,
4038
4039            } = slot_;
4040        }
4041
4042        ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4043
4044        let key = unsafe { key.deref_unchecked() };
4045
4046        if key.len() > 255 {
4047            return Err(::fidl_next::DecodeError::VectorTooLong {
4048                size: key.len() as u64,
4049                limit: 255,
4050            });
4051        }
4052
4053        ::fidl_next::Decode::decode(value.as_mut(), decoder_)?;
4054
4055        Ok(())
4056    }
4057}
4058
4059#[derive(PartialEq, Clone, Debug)]
4060pub struct CapabilityStoreDictionaryInsertRequest {
4061    pub id: u64,
4062
4063    pub item: crate::DictionaryItem,
4064}
4065
4066impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest {
4067    type Encoded = WireCapabilityStoreDictionaryInsertRequest<'static>;
4068}
4069
4070unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertRequest
4071where
4072    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4073    ___E: ::fidl_next::Encoder,
4074{
4075    #[inline]
4076    fn encode(
4077        self,
4078        encoder_: &mut ___E,
4079        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4080    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4081        ::fidl_next::munge! {
4082            let Self::Encoded {
4083                id,
4084                item,
4085
4086            } = out_;
4087        }
4088
4089        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4090
4091        ::fidl_next::Encode::encode(self.item, encoder_, item)?;
4092
4093        Ok(())
4094    }
4095}
4096
4097unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertRequest
4098where
4099    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4100    ___E: ::fidl_next::Encoder,
4101{
4102    #[inline]
4103    fn encode_ref(
4104        &self,
4105        encoder_: &mut ___E,
4106        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4107    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4108        ::fidl_next::munge! {
4109            let Self::Encoded {
4110
4111                id,
4112                item,
4113
4114            } = out_;
4115        }
4116
4117        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4118
4119        ::fidl_next::EncodeRef::encode_ref(&self.item, encoder_, item)?;
4120
4121        Ok(())
4122    }
4123}
4124
4125impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertRequest {
4126    type EncodedOption =
4127        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryInsertRequest<'static>>;
4128}
4129
4130unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertRequest
4131where
4132    ___E: ::fidl_next::Encoder + ?Sized,
4133    CapabilityStoreDictionaryInsertRequest: ::fidl_next::Encode<___E>,
4134{
4135    #[inline]
4136    fn encode_option(
4137        this: ::core::option::Option<Self>,
4138        encoder: &mut ___E,
4139        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4140    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4141        if let Some(inner) = this {
4142            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4143            ::fidl_next::WireBox::encode_present(out);
4144        } else {
4145            ::fidl_next::WireBox::encode_absent(out);
4146        }
4147
4148        Ok(())
4149    }
4150}
4151
4152unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertRequest
4153where
4154    ___E: ::fidl_next::Encoder + ?Sized,
4155    CapabilityStoreDictionaryInsertRequest: ::fidl_next::EncodeRef<___E>,
4156{
4157    #[inline]
4158    fn encode_option_ref(
4159        this: ::core::option::Option<&Self>,
4160        encoder: &mut ___E,
4161        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4162    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4163        if let Some(inner) = this {
4164            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4165            ::fidl_next::WireBox::encode_present(out);
4166        } else {
4167            ::fidl_next::WireBox::encode_absent(out);
4168        }
4169
4170        Ok(())
4171    }
4172}
4173
4174impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryInsertRequest<'de>>
4175    for CapabilityStoreDictionaryInsertRequest
4176{
4177    #[inline]
4178    fn from_wire(wire: WireCapabilityStoreDictionaryInsertRequest<'de>) -> Self {
4179        Self {
4180            id: ::fidl_next::FromWire::from_wire(wire.id),
4181
4182            item: ::fidl_next::FromWire::from_wire(wire.item),
4183        }
4184    }
4185}
4186
4187impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryInsertRequest<'de> {
4188    type Natural = CapabilityStoreDictionaryInsertRequest;
4189}
4190
4191impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryInsertRequest<'de>>
4192    for CapabilityStoreDictionaryInsertRequest
4193{
4194    #[inline]
4195    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryInsertRequest<'de>) -> Self {
4196        Self {
4197            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4198
4199            item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
4200        }
4201    }
4202}
4203
4204/// The wire type corresponding to [`CapabilityStoreDictionaryInsertRequest`].
4205#[derive(Debug)]
4206#[repr(C)]
4207pub struct WireCapabilityStoreDictionaryInsertRequest<'de> {
4208    pub id: ::fidl_next::WireU64,
4209
4210    pub item: crate::WireDictionaryItem<'de>,
4211}
4212static_assertions::const_assert_eq!(
4213    std::mem::size_of::<WireCapabilityStoreDictionaryInsertRequest<'_>>(),
4214    32
4215);
4216static_assertions::const_assert_eq!(
4217    std::mem::align_of::<WireCapabilityStoreDictionaryInsertRequest<'_>>(),
4218    8
4219);
4220
4221static_assertions::const_assert_eq!(
4222    std::mem::offset_of!(WireCapabilityStoreDictionaryInsertRequest<'_>, id),
4223    0
4224);
4225
4226static_assertions::const_assert_eq!(
4227    std::mem::offset_of!(WireCapabilityStoreDictionaryInsertRequest<'_>, item),
4228    8
4229);
4230
4231unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryInsertRequest<'static> {
4232    type Decoded<'de> = WireCapabilityStoreDictionaryInsertRequest<'de>;
4233
4234    #[inline]
4235    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4236        ::fidl_next::munge! {
4237            let Self {
4238
4239                id,
4240                item,
4241
4242            } = &mut *out_;
4243        }
4244
4245        ::fidl_next::Wire::zero_padding(id);
4246
4247        ::fidl_next::Wire::zero_padding(item);
4248    }
4249}
4250
4251unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryInsertRequest<'static>
4252where
4253    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4254    ___D: ::fidl_next::Decoder,
4255{
4256    fn decode(
4257        slot_: ::fidl_next::Slot<'_, Self>,
4258        decoder_: &mut ___D,
4259    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4260        ::fidl_next::munge! {
4261            let Self {
4262
4263                mut id,
4264                mut item,
4265
4266            } = slot_;
4267        }
4268
4269        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4270
4271        ::fidl_next::Decode::decode(item.as_mut(), decoder_)?;
4272
4273        Ok(())
4274    }
4275}
4276
4277pub type CapabilityStoreDictionaryInsertResponse = ();
4278
4279/// The wire type corresponding to [`CapabilityStoreDictionaryInsertResponse`].
4280pub type WireCapabilityStoreDictionaryInsertResponse = ();
4281
4282#[derive(PartialEq, Clone, Debug)]
4283pub struct CapabilityStoreDictionaryGetRequest {
4284    pub id: u64,
4285
4286    pub key: ::std::string::String,
4287
4288    pub dest_id: u64,
4289}
4290
4291impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest {
4292    type Encoded = WireCapabilityStoreDictionaryGetRequest<'static>;
4293}
4294
4295unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetRequest
4296where
4297    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4298    ___E: ::fidl_next::Encoder,
4299{
4300    #[inline]
4301    fn encode(
4302        self,
4303        encoder_: &mut ___E,
4304        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4305    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4306        ::fidl_next::munge! {
4307            let Self::Encoded {
4308                id,
4309                key,
4310                dest_id,
4311
4312            } = out_;
4313        }
4314
4315        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4316
4317        ::fidl_next::Encode::encode(self.key, encoder_, key)?;
4318
4319        ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
4320
4321        Ok(())
4322    }
4323}
4324
4325unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetRequest
4326where
4327    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4328    ___E: ::fidl_next::Encoder,
4329{
4330    #[inline]
4331    fn encode_ref(
4332        &self,
4333        encoder_: &mut ___E,
4334        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4335    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4336        ::fidl_next::munge! {
4337            let Self::Encoded {
4338
4339                id,
4340                key,
4341                dest_id,
4342
4343            } = out_;
4344        }
4345
4346        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4347
4348        ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
4349
4350        ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
4351
4352        Ok(())
4353    }
4354}
4355
4356impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetRequest {
4357    type EncodedOption =
4358        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryGetRequest<'static>>;
4359}
4360
4361unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetRequest
4362where
4363    ___E: ::fidl_next::Encoder + ?Sized,
4364    CapabilityStoreDictionaryGetRequest: ::fidl_next::Encode<___E>,
4365{
4366    #[inline]
4367    fn encode_option(
4368        this: ::core::option::Option<Self>,
4369        encoder: &mut ___E,
4370        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4371    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4372        if let Some(inner) = this {
4373            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4374            ::fidl_next::WireBox::encode_present(out);
4375        } else {
4376            ::fidl_next::WireBox::encode_absent(out);
4377        }
4378
4379        Ok(())
4380    }
4381}
4382
4383unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetRequest
4384where
4385    ___E: ::fidl_next::Encoder + ?Sized,
4386    CapabilityStoreDictionaryGetRequest: ::fidl_next::EncodeRef<___E>,
4387{
4388    #[inline]
4389    fn encode_option_ref(
4390        this: ::core::option::Option<&Self>,
4391        encoder: &mut ___E,
4392        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4393    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4394        if let Some(inner) = this {
4395            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4396            ::fidl_next::WireBox::encode_present(out);
4397        } else {
4398            ::fidl_next::WireBox::encode_absent(out);
4399        }
4400
4401        Ok(())
4402    }
4403}
4404
4405impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryGetRequest<'de>>
4406    for CapabilityStoreDictionaryGetRequest
4407{
4408    #[inline]
4409    fn from_wire(wire: WireCapabilityStoreDictionaryGetRequest<'de>) -> Self {
4410        Self {
4411            id: ::fidl_next::FromWire::from_wire(wire.id),
4412
4413            key: ::fidl_next::FromWire::from_wire(wire.key),
4414
4415            dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4416        }
4417    }
4418}
4419
4420impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryGetRequest<'de> {
4421    type Natural = CapabilityStoreDictionaryGetRequest;
4422}
4423
4424impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryGetRequest<'de>>
4425    for CapabilityStoreDictionaryGetRequest
4426{
4427    #[inline]
4428    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryGetRequest<'de>) -> Self {
4429        Self {
4430            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4431
4432            key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4433
4434            dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4435        }
4436    }
4437}
4438
4439/// The wire type corresponding to [`CapabilityStoreDictionaryGetRequest`].
4440#[derive(Debug)]
4441#[repr(C)]
4442pub struct WireCapabilityStoreDictionaryGetRequest<'de> {
4443    pub id: ::fidl_next::WireU64,
4444
4445    pub key: ::fidl_next::WireString<'de>,
4446
4447    pub dest_id: ::fidl_next::WireU64,
4448}
4449static_assertions::const_assert_eq!(
4450    std::mem::size_of::<WireCapabilityStoreDictionaryGetRequest<'_>>(),
4451    32
4452);
4453static_assertions::const_assert_eq!(
4454    std::mem::align_of::<WireCapabilityStoreDictionaryGetRequest<'_>>(),
4455    8
4456);
4457
4458static_assertions::const_assert_eq!(
4459    std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, id),
4460    0
4461);
4462
4463static_assertions::const_assert_eq!(
4464    std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, key),
4465    8
4466);
4467
4468static_assertions::const_assert_eq!(
4469    std::mem::offset_of!(WireCapabilityStoreDictionaryGetRequest<'_>, dest_id),
4470    24
4471);
4472
4473unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryGetRequest<'static> {
4474    type Decoded<'de> = WireCapabilityStoreDictionaryGetRequest<'de>;
4475
4476    #[inline]
4477    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4478        ::fidl_next::munge! {
4479            let Self {
4480
4481                id,
4482                key,
4483                dest_id,
4484
4485            } = &mut *out_;
4486        }
4487
4488        ::fidl_next::Wire::zero_padding(id);
4489
4490        ::fidl_next::Wire::zero_padding(key);
4491
4492        ::fidl_next::Wire::zero_padding(dest_id);
4493    }
4494}
4495
4496unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryGetRequest<'static>
4497where
4498    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4499    ___D: ::fidl_next::Decoder,
4500{
4501    fn decode(
4502        slot_: ::fidl_next::Slot<'_, Self>,
4503        decoder_: &mut ___D,
4504    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4505        ::fidl_next::munge! {
4506            let Self {
4507
4508                mut id,
4509                mut key,
4510                mut dest_id,
4511
4512            } = slot_;
4513        }
4514
4515        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4516
4517        ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4518
4519        let key = unsafe { key.deref_unchecked() };
4520
4521        if key.len() > 255 {
4522            return Err(::fidl_next::DecodeError::VectorTooLong {
4523                size: key.len() as u64,
4524                limit: 255,
4525            });
4526        }
4527
4528        ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
4529
4530        Ok(())
4531    }
4532}
4533
4534pub type CapabilityStoreDictionaryGetResponse = ();
4535
4536/// The wire type corresponding to [`CapabilityStoreDictionaryGetResponse`].
4537pub type WireCapabilityStoreDictionaryGetResponse = ();
4538
4539#[doc = " A [CapabilityId] wrapped in a struct. This is useful for putting a [CapabilityId] in a `box<>`,\n which FIDL does not allow for pure integral types.\n"]
4540#[derive(PartialEq, Clone, Debug)]
4541#[repr(C)]
4542pub struct WrappedCapabilityId {
4543    pub id: u64,
4544}
4545
4546impl ::fidl_next::Encodable for WrappedCapabilityId {
4547    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireWrappedCapabilityId> = unsafe {
4548        ::fidl_next::CopyOptimization::enable_if(
4549            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4550        )
4551    };
4552
4553    type Encoded = WireWrappedCapabilityId;
4554}
4555
4556unsafe impl<___E> ::fidl_next::Encode<___E> for WrappedCapabilityId
4557where
4558    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4559{
4560    #[inline]
4561    fn encode(
4562        self,
4563        encoder_: &mut ___E,
4564        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4565    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4566        ::fidl_next::munge! {
4567            let Self::Encoded {
4568                id,
4569
4570            } = out_;
4571        }
4572
4573        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4574
4575        Ok(())
4576    }
4577}
4578
4579unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WrappedCapabilityId
4580where
4581    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4582{
4583    #[inline]
4584    fn encode_ref(
4585        &self,
4586        encoder_: &mut ___E,
4587        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4588    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4589        ::fidl_next::munge! {
4590            let Self::Encoded {
4591
4592                id,
4593
4594            } = out_;
4595        }
4596
4597        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4598
4599        Ok(())
4600    }
4601}
4602
4603impl ::fidl_next::EncodableOption for WrappedCapabilityId {
4604    type EncodedOption = ::fidl_next::WireBox<'static, WireWrappedCapabilityId>;
4605}
4606
4607unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WrappedCapabilityId
4608where
4609    ___E: ::fidl_next::Encoder + ?Sized,
4610    WrappedCapabilityId: ::fidl_next::Encode<___E>,
4611{
4612    #[inline]
4613    fn encode_option(
4614        this: ::core::option::Option<Self>,
4615        encoder: &mut ___E,
4616        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4617    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4618        if let Some(inner) = this {
4619            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4620            ::fidl_next::WireBox::encode_present(out);
4621        } else {
4622            ::fidl_next::WireBox::encode_absent(out);
4623        }
4624
4625        Ok(())
4626    }
4627}
4628
4629unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WrappedCapabilityId
4630where
4631    ___E: ::fidl_next::Encoder + ?Sized,
4632    WrappedCapabilityId: ::fidl_next::EncodeRef<___E>,
4633{
4634    #[inline]
4635    fn encode_option_ref(
4636        this: ::core::option::Option<&Self>,
4637        encoder: &mut ___E,
4638        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4639    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4640        if let Some(inner) = this {
4641            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4642            ::fidl_next::WireBox::encode_present(out);
4643        } else {
4644            ::fidl_next::WireBox::encode_absent(out);
4645        }
4646
4647        Ok(())
4648    }
4649}
4650
4651impl ::fidl_next::FromWire<WireWrappedCapabilityId> for WrappedCapabilityId {
4652    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireWrappedCapabilityId, Self> = unsafe {
4653        ::fidl_next::CopyOptimization::enable_if(
4654            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4655                .is_enabled(),
4656        )
4657    };
4658
4659    #[inline]
4660    fn from_wire(wire: WireWrappedCapabilityId) -> Self {
4661        Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
4662    }
4663}
4664
4665impl ::fidl_next::IntoNatural for WireWrappedCapabilityId {
4666    type Natural = WrappedCapabilityId;
4667}
4668
4669impl ::fidl_next::FromWireRef<WireWrappedCapabilityId> for WrappedCapabilityId {
4670    #[inline]
4671    fn from_wire_ref(wire: &WireWrappedCapabilityId) -> Self {
4672        Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
4673    }
4674}
4675
4676/// The wire type corresponding to [`WrappedCapabilityId`].
4677#[derive(Clone, Debug)]
4678#[repr(C)]
4679pub struct WireWrappedCapabilityId {
4680    pub id: ::fidl_next::WireU64,
4681}
4682static_assertions::const_assert_eq!(std::mem::size_of::<WireWrappedCapabilityId>(), 8);
4683static_assertions::const_assert_eq!(std::mem::align_of::<WireWrappedCapabilityId>(), 8);
4684
4685static_assertions::const_assert_eq!(std::mem::offset_of!(WireWrappedCapabilityId, id), 0);
4686
4687unsafe impl ::fidl_next::Wire for WireWrappedCapabilityId {
4688    type Decoded<'de> = WireWrappedCapabilityId;
4689
4690    #[inline]
4691    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4692        ::fidl_next::munge! {
4693            let Self {
4694
4695                id,
4696
4697            } = &mut *out_;
4698        }
4699
4700        ::fidl_next::Wire::zero_padding(id);
4701    }
4702}
4703
4704unsafe impl<___D> ::fidl_next::Decode<___D> for WireWrappedCapabilityId
4705where
4706    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4707{
4708    fn decode(
4709        slot_: ::fidl_next::Slot<'_, Self>,
4710        decoder_: &mut ___D,
4711    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4712        ::fidl_next::munge! {
4713            let Self {
4714
4715                mut id,
4716
4717            } = slot_;
4718        }
4719
4720        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4721
4722        Ok(())
4723    }
4724}
4725
4726pub type WrappedNewCapabilityId = crate::WrappedCapabilityId;
4727
4728/// The wire type corresponding to [`WrappedNewCapabilityId`].
4729pub type WireWrappedNewCapabilityId = crate::WireWrappedCapabilityId;
4730
4731#[derive(PartialEq, Clone, Debug)]
4732pub struct CapabilityStoreDictionaryRemoveRequest {
4733    pub id: u64,
4734
4735    pub key: ::std::string::String,
4736
4737    pub dest_id: ::core::option::Option<::std::boxed::Box<crate::WrappedCapabilityId>>,
4738}
4739
4740impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest {
4741    type Encoded = WireCapabilityStoreDictionaryRemoveRequest<'static>;
4742}
4743
4744unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveRequest
4745where
4746    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4747    ___E: ::fidl_next::Encoder,
4748{
4749    #[inline]
4750    fn encode(
4751        self,
4752        encoder_: &mut ___E,
4753        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4754    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4755        ::fidl_next::munge! {
4756            let Self::Encoded {
4757                id,
4758                key,
4759                dest_id,
4760
4761            } = out_;
4762        }
4763
4764        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
4765
4766        ::fidl_next::Encode::encode(self.key, encoder_, key)?;
4767
4768        ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
4769
4770        Ok(())
4771    }
4772}
4773
4774unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveRequest
4775where
4776    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4777    ___E: ::fidl_next::Encoder,
4778{
4779    #[inline]
4780    fn encode_ref(
4781        &self,
4782        encoder_: &mut ___E,
4783        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4784    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4785        ::fidl_next::munge! {
4786            let Self::Encoded {
4787
4788                id,
4789                key,
4790                dest_id,
4791
4792            } = out_;
4793        }
4794
4795        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
4796
4797        ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key)?;
4798
4799        ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
4800
4801        Ok(())
4802    }
4803}
4804
4805impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveRequest {
4806    type EncodedOption =
4807        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryRemoveRequest<'static>>;
4808}
4809
4810unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveRequest
4811where
4812    ___E: ::fidl_next::Encoder + ?Sized,
4813    CapabilityStoreDictionaryRemoveRequest: ::fidl_next::Encode<___E>,
4814{
4815    #[inline]
4816    fn encode_option(
4817        this: ::core::option::Option<Self>,
4818        encoder: &mut ___E,
4819        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4820    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4821        if let Some(inner) = this {
4822            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4823            ::fidl_next::WireBox::encode_present(out);
4824        } else {
4825            ::fidl_next::WireBox::encode_absent(out);
4826        }
4827
4828        Ok(())
4829    }
4830}
4831
4832unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveRequest
4833where
4834    ___E: ::fidl_next::Encoder + ?Sized,
4835    CapabilityStoreDictionaryRemoveRequest: ::fidl_next::EncodeRef<___E>,
4836{
4837    #[inline]
4838    fn encode_option_ref(
4839        this: ::core::option::Option<&Self>,
4840        encoder: &mut ___E,
4841        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4842    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4843        if let Some(inner) = this {
4844            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4845            ::fidl_next::WireBox::encode_present(out);
4846        } else {
4847            ::fidl_next::WireBox::encode_absent(out);
4848        }
4849
4850        Ok(())
4851    }
4852}
4853
4854impl<'de> ::fidl_next::FromWire<WireCapabilityStoreDictionaryRemoveRequest<'de>>
4855    for CapabilityStoreDictionaryRemoveRequest
4856{
4857    #[inline]
4858    fn from_wire(wire: WireCapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4859        Self {
4860            id: ::fidl_next::FromWire::from_wire(wire.id),
4861
4862            key: ::fidl_next::FromWire::from_wire(wire.key),
4863
4864            dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4865        }
4866    }
4867}
4868
4869impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryRemoveRequest<'de> {
4870    type Natural = CapabilityStoreDictionaryRemoveRequest;
4871}
4872
4873impl<'de> ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryRemoveRequest<'de>>
4874    for CapabilityStoreDictionaryRemoveRequest
4875{
4876    #[inline]
4877    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4878        Self {
4879            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4880
4881            key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4882
4883            dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4884        }
4885    }
4886}
4887
4888/// The wire type corresponding to [`CapabilityStoreDictionaryRemoveRequest`].
4889#[derive(Debug)]
4890#[repr(C)]
4891pub struct WireCapabilityStoreDictionaryRemoveRequest<'de> {
4892    pub id: ::fidl_next::WireU64,
4893
4894    pub key: ::fidl_next::WireString<'de>,
4895
4896    pub dest_id: ::fidl_next::WireBox<'de, crate::WireWrappedCapabilityId>,
4897}
4898static_assertions::const_assert_eq!(
4899    std::mem::size_of::<WireCapabilityStoreDictionaryRemoveRequest<'_>>(),
4900    32
4901);
4902static_assertions::const_assert_eq!(
4903    std::mem::align_of::<WireCapabilityStoreDictionaryRemoveRequest<'_>>(),
4904    8
4905);
4906
4907static_assertions::const_assert_eq!(
4908    std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, id),
4909    0
4910);
4911
4912static_assertions::const_assert_eq!(
4913    std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, key),
4914    8
4915);
4916
4917static_assertions::const_assert_eq!(
4918    std::mem::offset_of!(WireCapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
4919    24
4920);
4921
4922unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryRemoveRequest<'static> {
4923    type Decoded<'de> = WireCapabilityStoreDictionaryRemoveRequest<'de>;
4924
4925    #[inline]
4926    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4927        ::fidl_next::munge! {
4928            let Self {
4929
4930                id,
4931                key,
4932                dest_id,
4933
4934            } = &mut *out_;
4935        }
4936
4937        ::fidl_next::Wire::zero_padding(id);
4938
4939        ::fidl_next::Wire::zero_padding(key);
4940
4941        ::fidl_next::Wire::zero_padding(dest_id);
4942    }
4943}
4944
4945unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryRemoveRequest<'static>
4946where
4947    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4948    ___D: ::fidl_next::Decoder,
4949{
4950    fn decode(
4951        slot_: ::fidl_next::Slot<'_, Self>,
4952        decoder_: &mut ___D,
4953    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4954        ::fidl_next::munge! {
4955            let Self {
4956
4957                mut id,
4958                mut key,
4959                mut dest_id,
4960
4961            } = slot_;
4962        }
4963
4964        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
4965
4966        ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
4967
4968        let key = unsafe { key.deref_unchecked() };
4969
4970        if key.len() > 255 {
4971            return Err(::fidl_next::DecodeError::VectorTooLong {
4972                size: key.len() as u64,
4973                limit: 255,
4974            });
4975        }
4976
4977        ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
4978
4979        Ok(())
4980    }
4981}
4982
4983pub type CapabilityStoreDictionaryRemoveResponse = ();
4984
4985/// The wire type corresponding to [`CapabilityStoreDictionaryRemoveResponse`].
4986pub type WireCapabilityStoreDictionaryRemoveResponse = ();
4987
4988#[derive(PartialEq, Clone, Debug)]
4989#[repr(C)]
4990pub struct CapabilityStoreDictionaryCopyRequest {
4991    pub id: u64,
4992
4993    pub dest_id: u64,
4994}
4995
4996impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest {
4997    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4998        Self,
4999        WireCapabilityStoreDictionaryCopyRequest,
5000    > = unsafe {
5001        ::fidl_next::CopyOptimization::enable_if(
5002            true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
5003                && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
5004        )
5005    };
5006
5007    type Encoded = WireCapabilityStoreDictionaryCopyRequest;
5008}
5009
5010unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest
5011where
5012    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5013{
5014    #[inline]
5015    fn encode(
5016        self,
5017        encoder_: &mut ___E,
5018        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5019    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5020        ::fidl_next::munge! {
5021            let Self::Encoded {
5022                id,
5023                dest_id,
5024
5025            } = out_;
5026        }
5027
5028        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5029
5030        ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
5031
5032        Ok(())
5033    }
5034}
5035
5036unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyRequest
5037where
5038    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5039{
5040    #[inline]
5041    fn encode_ref(
5042        &self,
5043        encoder_: &mut ___E,
5044        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5045    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5046        ::fidl_next::munge! {
5047            let Self::Encoded {
5048
5049                id,
5050                dest_id,
5051
5052            } = out_;
5053        }
5054
5055        ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id)?;
5056
5057        ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id)?;
5058
5059        Ok(())
5060    }
5061}
5062
5063impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyRequest {
5064    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryCopyRequest>;
5065}
5066
5067unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyRequest
5068where
5069    ___E: ::fidl_next::Encoder + ?Sized,
5070    CapabilityStoreDictionaryCopyRequest: ::fidl_next::Encode<___E>,
5071{
5072    #[inline]
5073    fn encode_option(
5074        this: ::core::option::Option<Self>,
5075        encoder: &mut ___E,
5076        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5077    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5078        if let Some(inner) = this {
5079            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5080            ::fidl_next::WireBox::encode_present(out);
5081        } else {
5082            ::fidl_next::WireBox::encode_absent(out);
5083        }
5084
5085        Ok(())
5086    }
5087}
5088
5089unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyRequest
5090where
5091    ___E: ::fidl_next::Encoder + ?Sized,
5092    CapabilityStoreDictionaryCopyRequest: ::fidl_next::EncodeRef<___E>,
5093{
5094    #[inline]
5095    fn encode_option_ref(
5096        this: ::core::option::Option<&Self>,
5097        encoder: &mut ___E,
5098        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5099    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5100        if let Some(inner) = this {
5101            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5102            ::fidl_next::WireBox::encode_present(out);
5103        } else {
5104            ::fidl_next::WireBox::encode_absent(out);
5105        }
5106
5107        Ok(())
5108    }
5109}
5110
5111impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryCopyRequest>
5112    for CapabilityStoreDictionaryCopyRequest
5113{
5114    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5115        WireCapabilityStoreDictionaryCopyRequest,
5116        Self,
5117    > = unsafe {
5118        ::fidl_next::CopyOptimization::enable_if(
5119            true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
5120                .is_enabled()
5121                && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
5122                    .is_enabled(),
5123        )
5124    };
5125
5126    #[inline]
5127    fn from_wire(wire: WireCapabilityStoreDictionaryCopyRequest) -> Self {
5128        Self {
5129            id: ::fidl_next::FromWire::from_wire(wire.id),
5130
5131            dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
5132        }
5133    }
5134}
5135
5136impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryCopyRequest {
5137    type Natural = CapabilityStoreDictionaryCopyRequest;
5138}
5139
5140impl ::fidl_next::FromWireRef<WireCapabilityStoreDictionaryCopyRequest>
5141    for CapabilityStoreDictionaryCopyRequest
5142{
5143    #[inline]
5144    fn from_wire_ref(wire: &WireCapabilityStoreDictionaryCopyRequest) -> Self {
5145        Self {
5146            id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
5147
5148            dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
5149        }
5150    }
5151}
5152
5153/// The wire type corresponding to [`CapabilityStoreDictionaryCopyRequest`].
5154#[derive(Clone, Debug)]
5155#[repr(C)]
5156pub struct WireCapabilityStoreDictionaryCopyRequest {
5157    pub id: ::fidl_next::WireU64,
5158
5159    pub dest_id: ::fidl_next::WireU64,
5160}
5161static_assertions::const_assert_eq!(
5162    std::mem::size_of::<WireCapabilityStoreDictionaryCopyRequest>(),
5163    16
5164);
5165static_assertions::const_assert_eq!(
5166    std::mem::align_of::<WireCapabilityStoreDictionaryCopyRequest>(),
5167    8
5168);
5169
5170static_assertions::const_assert_eq!(
5171    std::mem::offset_of!(WireCapabilityStoreDictionaryCopyRequest, id),
5172    0
5173);
5174
5175static_assertions::const_assert_eq!(
5176    std::mem::offset_of!(WireCapabilityStoreDictionaryCopyRequest, dest_id),
5177    8
5178);
5179
5180unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryCopyRequest {
5181    type Decoded<'de> = WireCapabilityStoreDictionaryCopyRequest;
5182
5183    #[inline]
5184    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5185        ::fidl_next::munge! {
5186            let Self {
5187
5188                id,
5189                dest_id,
5190
5191            } = &mut *out_;
5192        }
5193
5194        ::fidl_next::Wire::zero_padding(id);
5195
5196        ::fidl_next::Wire::zero_padding(dest_id);
5197    }
5198}
5199
5200unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryCopyRequest
5201where
5202    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5203{
5204    fn decode(
5205        slot_: ::fidl_next::Slot<'_, Self>,
5206        decoder_: &mut ___D,
5207    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5208        ::fidl_next::munge! {
5209            let Self {
5210
5211                mut id,
5212                mut dest_id,
5213
5214            } = slot_;
5215        }
5216
5217        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5218
5219        ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_)?;
5220
5221        Ok(())
5222    }
5223}
5224
5225pub type CapabilityStoreDictionaryCopyResponse = ();
5226
5227/// The wire type corresponding to [`CapabilityStoreDictionaryCopyResponse`].
5228pub type WireCapabilityStoreDictionaryCopyResponse = ();
5229
5230#[derive(PartialEq, Debug)]
5231pub struct CapabilityStoreDictionaryKeysRequest {
5232    pub id: u64,
5233
5234    pub iterator:
5235        ::fidl_next::ServerEnd<crate::DictionaryKeysIterator, ::fidl_next::fuchsia::zx::Channel>,
5236}
5237
5238impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest {
5239    type Encoded = WireCapabilityStoreDictionaryKeysRequest;
5240}
5241
5242unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest
5243where
5244    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5245    ___E: ::fidl_next::fuchsia::HandleEncoder,
5246{
5247    #[inline]
5248    fn encode(
5249        self,
5250        encoder_: &mut ___E,
5251        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5252    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5253        ::fidl_next::munge! {
5254            let Self::Encoded {
5255                id,
5256                iterator,
5257
5258            } = out_;
5259        }
5260
5261        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5262
5263        ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5264
5265        Ok(())
5266    }
5267}
5268
5269impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysRequest {
5270    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryKeysRequest>;
5271}
5272
5273unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysRequest
5274where
5275    ___E: ::fidl_next::Encoder + ?Sized,
5276    CapabilityStoreDictionaryKeysRequest: ::fidl_next::Encode<___E>,
5277{
5278    #[inline]
5279    fn encode_option(
5280        this: ::core::option::Option<Self>,
5281        encoder: &mut ___E,
5282        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5283    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5284        if let Some(inner) = this {
5285            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5286            ::fidl_next::WireBox::encode_present(out);
5287        } else {
5288            ::fidl_next::WireBox::encode_absent(out);
5289        }
5290
5291        Ok(())
5292    }
5293}
5294
5295impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryKeysRequest>
5296    for CapabilityStoreDictionaryKeysRequest
5297{
5298    #[inline]
5299    fn from_wire(wire: WireCapabilityStoreDictionaryKeysRequest) -> Self {
5300        Self {
5301            id: ::fidl_next::FromWire::from_wire(wire.id),
5302
5303            iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5304        }
5305    }
5306}
5307
5308impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryKeysRequest {
5309    type Natural = CapabilityStoreDictionaryKeysRequest;
5310}
5311
5312/// The wire type corresponding to [`CapabilityStoreDictionaryKeysRequest`].
5313#[derive(Debug)]
5314#[repr(C)]
5315pub struct WireCapabilityStoreDictionaryKeysRequest {
5316    pub id: ::fidl_next::WireU64,
5317
5318    pub iterator:
5319        ::fidl_next::ServerEnd<crate::DictionaryKeysIterator, ::fidl_next::fuchsia::WireChannel>,
5320}
5321static_assertions::const_assert_eq!(
5322    std::mem::size_of::<WireCapabilityStoreDictionaryKeysRequest>(),
5323    16
5324);
5325static_assertions::const_assert_eq!(
5326    std::mem::align_of::<WireCapabilityStoreDictionaryKeysRequest>(),
5327    8
5328);
5329
5330static_assertions::const_assert_eq!(
5331    std::mem::offset_of!(WireCapabilityStoreDictionaryKeysRequest, id),
5332    0
5333);
5334
5335static_assertions::const_assert_eq!(
5336    std::mem::offset_of!(WireCapabilityStoreDictionaryKeysRequest, iterator),
5337    8
5338);
5339
5340unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryKeysRequest {
5341    type Decoded<'de> = WireCapabilityStoreDictionaryKeysRequest;
5342
5343    #[inline]
5344    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5345        ::fidl_next::munge! {
5346            let Self {
5347
5348                id,
5349                iterator,
5350
5351            } = &mut *out_;
5352        }
5353
5354        ::fidl_next::Wire::zero_padding(id);
5355
5356        ::fidl_next::Wire::zero_padding(iterator);
5357
5358        unsafe {
5359            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5360        }
5361    }
5362}
5363
5364unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryKeysRequest
5365where
5366    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5367    ___D: ::fidl_next::fuchsia::HandleDecoder,
5368{
5369    fn decode(
5370        slot_: ::fidl_next::Slot<'_, Self>,
5371        decoder_: &mut ___D,
5372    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5373        ::fidl_next::munge! {
5374            let Self {
5375
5376                mut id,
5377                mut iterator,
5378
5379            } = slot_;
5380        }
5381
5382        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5383
5384        ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5385
5386        Ok(())
5387    }
5388}
5389
5390pub type CapabilityStoreDictionaryKeysResponse = ();
5391
5392/// The wire type corresponding to [`CapabilityStoreDictionaryKeysResponse`].
5393pub type WireCapabilityStoreDictionaryKeysResponse = ();
5394
5395#[derive(PartialEq, Debug)]
5396pub struct CapabilityStoreDictionaryEnumerateRequest {
5397    pub id: u64,
5398
5399    pub iterator: ::fidl_next::ServerEnd<
5400        crate::DictionaryEnumerateIterator,
5401        ::fidl_next::fuchsia::zx::Channel,
5402    >,
5403}
5404
5405impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest {
5406    type Encoded = WireCapabilityStoreDictionaryEnumerateRequest;
5407}
5408
5409unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateRequest
5410where
5411    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5412    ___E: ::fidl_next::fuchsia::HandleEncoder,
5413{
5414    #[inline]
5415    fn encode(
5416        self,
5417        encoder_: &mut ___E,
5418        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5419    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5420        ::fidl_next::munge! {
5421            let Self::Encoded {
5422                id,
5423                iterator,
5424
5425            } = out_;
5426        }
5427
5428        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5429
5430        ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5431
5432        Ok(())
5433    }
5434}
5435
5436impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateRequest {
5437    type EncodedOption =
5438        ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryEnumerateRequest>;
5439}
5440
5441unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateRequest
5442where
5443    ___E: ::fidl_next::Encoder + ?Sized,
5444    CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Encode<___E>,
5445{
5446    #[inline]
5447    fn encode_option(
5448        this: ::core::option::Option<Self>,
5449        encoder: &mut ___E,
5450        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5451    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5452        if let Some(inner) = this {
5453            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5454            ::fidl_next::WireBox::encode_present(out);
5455        } else {
5456            ::fidl_next::WireBox::encode_absent(out);
5457        }
5458
5459        Ok(())
5460    }
5461}
5462
5463impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryEnumerateRequest>
5464    for CapabilityStoreDictionaryEnumerateRequest
5465{
5466    #[inline]
5467    fn from_wire(wire: WireCapabilityStoreDictionaryEnumerateRequest) -> Self {
5468        Self {
5469            id: ::fidl_next::FromWire::from_wire(wire.id),
5470
5471            iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5472        }
5473    }
5474}
5475
5476impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryEnumerateRequest {
5477    type Natural = CapabilityStoreDictionaryEnumerateRequest;
5478}
5479
5480/// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateRequest`].
5481#[derive(Debug)]
5482#[repr(C)]
5483pub struct WireCapabilityStoreDictionaryEnumerateRequest {
5484    pub id: ::fidl_next::WireU64,
5485
5486    pub iterator: ::fidl_next::ServerEnd<
5487        crate::DictionaryEnumerateIterator,
5488        ::fidl_next::fuchsia::WireChannel,
5489    >,
5490}
5491static_assertions::const_assert_eq!(
5492    std::mem::size_of::<WireCapabilityStoreDictionaryEnumerateRequest>(),
5493    16
5494);
5495static_assertions::const_assert_eq!(
5496    std::mem::align_of::<WireCapabilityStoreDictionaryEnumerateRequest>(),
5497    8
5498);
5499
5500static_assertions::const_assert_eq!(
5501    std::mem::offset_of!(WireCapabilityStoreDictionaryEnumerateRequest, id),
5502    0
5503);
5504
5505static_assertions::const_assert_eq!(
5506    std::mem::offset_of!(WireCapabilityStoreDictionaryEnumerateRequest, iterator),
5507    8
5508);
5509
5510unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryEnumerateRequest {
5511    type Decoded<'de> = WireCapabilityStoreDictionaryEnumerateRequest;
5512
5513    #[inline]
5514    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5515        ::fidl_next::munge! {
5516            let Self {
5517
5518                id,
5519                iterator,
5520
5521            } = &mut *out_;
5522        }
5523
5524        ::fidl_next::Wire::zero_padding(id);
5525
5526        ::fidl_next::Wire::zero_padding(iterator);
5527
5528        unsafe {
5529            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5530        }
5531    }
5532}
5533
5534unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryEnumerateRequest
5535where
5536    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5537    ___D: ::fidl_next::fuchsia::HandleDecoder,
5538{
5539    fn decode(
5540        slot_: ::fidl_next::Slot<'_, Self>,
5541        decoder_: &mut ___D,
5542    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5543        ::fidl_next::munge! {
5544            let Self {
5545
5546                mut id,
5547                mut iterator,
5548
5549            } = slot_;
5550        }
5551
5552        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5553
5554        ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5555
5556        Ok(())
5557    }
5558}
5559
5560pub type CapabilityStoreDictionaryEnumerateResponse = ();
5561
5562/// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateResponse`].
5563pub type WireCapabilityStoreDictionaryEnumerateResponse = ();
5564
5565#[derive(PartialEq, Debug)]
5566pub struct CapabilityStoreDictionaryDrainRequest {
5567    pub id: u64,
5568
5569    pub iterator: ::core::option::Option<
5570        ::fidl_next::ServerEnd<crate::DictionaryDrainIterator, ::fidl_next::fuchsia::zx::Channel>,
5571    >,
5572}
5573
5574impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest {
5575    type Encoded = WireCapabilityStoreDictionaryDrainRequest;
5576}
5577
5578unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainRequest
5579where
5580    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5581    ___E: ::fidl_next::fuchsia::HandleEncoder,
5582{
5583    #[inline]
5584    fn encode(
5585        self,
5586        encoder_: &mut ___E,
5587        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5588    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5589        ::fidl_next::munge! {
5590            let Self::Encoded {
5591                id,
5592                iterator,
5593
5594            } = out_;
5595        }
5596
5597        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5598
5599        ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
5600
5601        Ok(())
5602    }
5603}
5604
5605impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainRequest {
5606    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDictionaryDrainRequest>;
5607}
5608
5609unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainRequest
5610where
5611    ___E: ::fidl_next::Encoder + ?Sized,
5612    CapabilityStoreDictionaryDrainRequest: ::fidl_next::Encode<___E>,
5613{
5614    #[inline]
5615    fn encode_option(
5616        this: ::core::option::Option<Self>,
5617        encoder: &mut ___E,
5618        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5619    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5620        if let Some(inner) = this {
5621            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5622            ::fidl_next::WireBox::encode_present(out);
5623        } else {
5624            ::fidl_next::WireBox::encode_absent(out);
5625        }
5626
5627        Ok(())
5628    }
5629}
5630
5631impl ::fidl_next::FromWire<WireCapabilityStoreDictionaryDrainRequest>
5632    for CapabilityStoreDictionaryDrainRequest
5633{
5634    #[inline]
5635    fn from_wire(wire: WireCapabilityStoreDictionaryDrainRequest) -> Self {
5636        Self {
5637            id: ::fidl_next::FromWire::from_wire(wire.id),
5638
5639            iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5640        }
5641    }
5642}
5643
5644impl ::fidl_next::IntoNatural for WireCapabilityStoreDictionaryDrainRequest {
5645    type Natural = CapabilityStoreDictionaryDrainRequest;
5646}
5647
5648/// The wire type corresponding to [`CapabilityStoreDictionaryDrainRequest`].
5649#[derive(Debug)]
5650#[repr(C)]
5651pub struct WireCapabilityStoreDictionaryDrainRequest {
5652    pub id: ::fidl_next::WireU64,
5653
5654    pub iterator: ::fidl_next::ServerEnd<
5655        crate::DictionaryDrainIterator,
5656        ::fidl_next::fuchsia::WireOptionalChannel,
5657    >,
5658}
5659static_assertions::const_assert_eq!(
5660    std::mem::size_of::<WireCapabilityStoreDictionaryDrainRequest>(),
5661    16
5662);
5663static_assertions::const_assert_eq!(
5664    std::mem::align_of::<WireCapabilityStoreDictionaryDrainRequest>(),
5665    8
5666);
5667
5668static_assertions::const_assert_eq!(
5669    std::mem::offset_of!(WireCapabilityStoreDictionaryDrainRequest, id),
5670    0
5671);
5672
5673static_assertions::const_assert_eq!(
5674    std::mem::offset_of!(WireCapabilityStoreDictionaryDrainRequest, iterator),
5675    8
5676);
5677
5678unsafe impl ::fidl_next::Wire for WireCapabilityStoreDictionaryDrainRequest {
5679    type Decoded<'de> = WireCapabilityStoreDictionaryDrainRequest;
5680
5681    #[inline]
5682    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5683        ::fidl_next::munge! {
5684            let Self {
5685
5686                id,
5687                iterator,
5688
5689            } = &mut *out_;
5690        }
5691
5692        ::fidl_next::Wire::zero_padding(id);
5693
5694        ::fidl_next::Wire::zero_padding(iterator);
5695
5696        unsafe {
5697            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
5698        }
5699    }
5700}
5701
5702unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDictionaryDrainRequest
5703where
5704    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5705    ___D: ::fidl_next::fuchsia::HandleDecoder,
5706{
5707    fn decode(
5708        slot_: ::fidl_next::Slot<'_, Self>,
5709        decoder_: &mut ___D,
5710    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5711        ::fidl_next::munge! {
5712            let Self {
5713
5714                mut id,
5715                mut iterator,
5716
5717            } = slot_;
5718        }
5719
5720        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
5721
5722        ::fidl_next::Decode::decode(iterator.as_mut(), decoder_)?;
5723
5724        Ok(())
5725    }
5726}
5727
5728pub type CapabilityStoreDictionaryDrainResponse = ();
5729
5730/// The wire type corresponding to [`CapabilityStoreDictionaryDrainResponse`].
5731pub type WireCapabilityStoreDictionaryDrainResponse = ();
5732
5733#[derive(PartialEq, Debug)]
5734pub struct CapabilityStoreExportResponse {
5735    pub capability: crate::Capability,
5736}
5737
5738impl ::fidl_next::Encodable for CapabilityStoreExportResponse {
5739    type Encoded = WireCapabilityStoreExportResponse<'static>;
5740}
5741
5742unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse
5743where
5744    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5745    ___E: ::fidl_next::Encoder,
5746    ___E: ::fidl_next::fuchsia::HandleEncoder,
5747{
5748    #[inline]
5749    fn encode(
5750        self,
5751        encoder_: &mut ___E,
5752        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5753    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5754        ::fidl_next::munge! {
5755            let Self::Encoded {
5756                capability,
5757
5758            } = out_;
5759        }
5760
5761        ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
5762
5763        Ok(())
5764    }
5765}
5766
5767impl ::fidl_next::EncodableOption for CapabilityStoreExportResponse {
5768    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreExportResponse<'static>>;
5769}
5770
5771unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportResponse
5772where
5773    ___E: ::fidl_next::Encoder + ?Sized,
5774    CapabilityStoreExportResponse: ::fidl_next::Encode<___E>,
5775{
5776    #[inline]
5777    fn encode_option(
5778        this: ::core::option::Option<Self>,
5779        encoder: &mut ___E,
5780        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5781    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5782        if let Some(inner) = this {
5783            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5784            ::fidl_next::WireBox::encode_present(out);
5785        } else {
5786            ::fidl_next::WireBox::encode_absent(out);
5787        }
5788
5789        Ok(())
5790    }
5791}
5792
5793impl<'de> ::fidl_next::FromWire<WireCapabilityStoreExportResponse<'de>>
5794    for CapabilityStoreExportResponse
5795{
5796    #[inline]
5797    fn from_wire(wire: WireCapabilityStoreExportResponse<'de>) -> Self {
5798        Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
5799    }
5800}
5801
5802impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreExportResponse<'de> {
5803    type Natural = CapabilityStoreExportResponse;
5804}
5805
5806/// The wire type corresponding to [`CapabilityStoreExportResponse`].
5807#[derive(Debug)]
5808#[repr(C)]
5809pub struct WireCapabilityStoreExportResponse<'de> {
5810    pub capability: crate::WireCapability<'de>,
5811}
5812static_assertions::const_assert_eq!(
5813    std::mem::size_of::<WireCapabilityStoreExportResponse<'_>>(),
5814    16
5815);
5816static_assertions::const_assert_eq!(
5817    std::mem::align_of::<WireCapabilityStoreExportResponse<'_>>(),
5818    8
5819);
5820
5821static_assertions::const_assert_eq!(
5822    std::mem::offset_of!(WireCapabilityStoreExportResponse<'_>, capability),
5823    0
5824);
5825
5826unsafe impl ::fidl_next::Wire for WireCapabilityStoreExportResponse<'static> {
5827    type Decoded<'de> = WireCapabilityStoreExportResponse<'de>;
5828
5829    #[inline]
5830    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5831        ::fidl_next::munge! {
5832            let Self {
5833
5834                capability,
5835
5836            } = &mut *out_;
5837        }
5838
5839        ::fidl_next::Wire::zero_padding(capability);
5840    }
5841}
5842
5843unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreExportResponse<'static>
5844where
5845    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5846    ___D: ::fidl_next::Decoder,
5847    ___D: ::fidl_next::fuchsia::HandleDecoder,
5848{
5849    fn decode(
5850        slot_: ::fidl_next::Slot<'_, Self>,
5851        decoder_: &mut ___D,
5852    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5853        ::fidl_next::munge! {
5854            let Self {
5855
5856                mut capability,
5857
5858            } = slot_;
5859        }
5860
5861        ::fidl_next::Decode::decode(capability.as_mut(), decoder_)?;
5862
5863        Ok(())
5864    }
5865}
5866
5867#[derive(PartialEq, Debug)]
5868pub struct CapabilityStoreImportRequest {
5869    pub id: u64,
5870
5871    pub capability: crate::Capability,
5872}
5873
5874impl ::fidl_next::Encodable for CapabilityStoreImportRequest {
5875    type Encoded = WireCapabilityStoreImportRequest<'static>;
5876}
5877
5878unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest
5879where
5880    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5881    ___E: ::fidl_next::Encoder,
5882    ___E: ::fidl_next::fuchsia::HandleEncoder,
5883{
5884    #[inline]
5885    fn encode(
5886        self,
5887        encoder_: &mut ___E,
5888        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5889    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5890        ::fidl_next::munge! {
5891            let Self::Encoded {
5892                id,
5893                capability,
5894
5895            } = out_;
5896        }
5897
5898        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
5899
5900        ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
5901
5902        Ok(())
5903    }
5904}
5905
5906impl ::fidl_next::EncodableOption for CapabilityStoreImportRequest {
5907    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreImportRequest<'static>>;
5908}
5909
5910unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportRequest
5911where
5912    ___E: ::fidl_next::Encoder + ?Sized,
5913    CapabilityStoreImportRequest: ::fidl_next::Encode<___E>,
5914{
5915    #[inline]
5916    fn encode_option(
5917        this: ::core::option::Option<Self>,
5918        encoder: &mut ___E,
5919        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5920    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5921        if let Some(inner) = this {
5922            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
5923            ::fidl_next::WireBox::encode_present(out);
5924        } else {
5925            ::fidl_next::WireBox::encode_absent(out);
5926        }
5927
5928        Ok(())
5929    }
5930}
5931
5932impl<'de> ::fidl_next::FromWire<WireCapabilityStoreImportRequest<'de>>
5933    for CapabilityStoreImportRequest
5934{
5935    #[inline]
5936    fn from_wire(wire: WireCapabilityStoreImportRequest<'de>) -> Self {
5937        Self {
5938            id: ::fidl_next::FromWire::from_wire(wire.id),
5939
5940            capability: ::fidl_next::FromWire::from_wire(wire.capability),
5941        }
5942    }
5943}
5944
5945impl<'de> ::fidl_next::IntoNatural for WireCapabilityStoreImportRequest<'de> {
5946    type Natural = CapabilityStoreImportRequest;
5947}
5948
5949/// The wire type corresponding to [`CapabilityStoreImportRequest`].
5950#[derive(Debug)]
5951#[repr(C)]
5952pub struct WireCapabilityStoreImportRequest<'de> {
5953    pub id: ::fidl_next::WireU64,
5954
5955    pub capability: crate::WireCapability<'de>,
5956}
5957static_assertions::const_assert_eq!(
5958    std::mem::size_of::<WireCapabilityStoreImportRequest<'_>>(),
5959    24
5960);
5961static_assertions::const_assert_eq!(
5962    std::mem::align_of::<WireCapabilityStoreImportRequest<'_>>(),
5963    8
5964);
5965
5966static_assertions::const_assert_eq!(
5967    std::mem::offset_of!(WireCapabilityStoreImportRequest<'_>, id),
5968    0
5969);
5970
5971static_assertions::const_assert_eq!(
5972    std::mem::offset_of!(WireCapabilityStoreImportRequest<'_>, capability),
5973    8
5974);
5975
5976unsafe impl ::fidl_next::Wire for WireCapabilityStoreImportRequest<'static> {
5977    type Decoded<'de> = WireCapabilityStoreImportRequest<'de>;
5978
5979    #[inline]
5980    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5981        ::fidl_next::munge! {
5982            let Self {
5983
5984                id,
5985                capability,
5986
5987            } = &mut *out_;
5988        }
5989
5990        ::fidl_next::Wire::zero_padding(id);
5991
5992        ::fidl_next::Wire::zero_padding(capability);
5993    }
5994}
5995
5996unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreImportRequest<'static>
5997where
5998    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5999    ___D: ::fidl_next::Decoder,
6000    ___D: ::fidl_next::fuchsia::HandleDecoder,
6001{
6002    fn decode(
6003        slot_: ::fidl_next::Slot<'_, Self>,
6004        decoder_: &mut ___D,
6005    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6006        ::fidl_next::munge! {
6007            let Self {
6008
6009                mut id,
6010                mut capability,
6011
6012            } = slot_;
6013        }
6014
6015        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6016
6017        ::fidl_next::Decode::decode(capability.as_mut(), decoder_)?;
6018
6019        Ok(())
6020    }
6021}
6022
6023#[derive(PartialEq, Debug)]
6024pub struct CapabilityStoreDirConnectorCreateRequest {
6025    pub id: u64,
6026
6027    pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
6028}
6029
6030impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest {
6031    type Encoded = WireCapabilityStoreDirConnectorCreateRequest;
6032}
6033
6034unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateRequest
6035where
6036    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6037    ___E: ::fidl_next::fuchsia::HandleEncoder,
6038{
6039    #[inline]
6040    fn encode(
6041        self,
6042        encoder_: &mut ___E,
6043        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6044    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6045        ::fidl_next::munge! {
6046            let Self::Encoded {
6047                id,
6048                receiver,
6049
6050            } = out_;
6051        }
6052
6053        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6054
6055        ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
6056
6057        Ok(())
6058    }
6059}
6060
6061impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateRequest {
6062    type EncodedOption =
6063        ::fidl_next::WireBox<'static, WireCapabilityStoreDirConnectorCreateRequest>;
6064}
6065
6066unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateRequest
6067where
6068    ___E: ::fidl_next::Encoder + ?Sized,
6069    CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Encode<___E>,
6070{
6071    #[inline]
6072    fn encode_option(
6073        this: ::core::option::Option<Self>,
6074        encoder: &mut ___E,
6075        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6076    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6077        if let Some(inner) = this {
6078            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6079            ::fidl_next::WireBox::encode_present(out);
6080        } else {
6081            ::fidl_next::WireBox::encode_absent(out);
6082        }
6083
6084        Ok(())
6085    }
6086}
6087
6088impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorCreateRequest>
6089    for CapabilityStoreDirConnectorCreateRequest
6090{
6091    #[inline]
6092    fn from_wire(wire: WireCapabilityStoreDirConnectorCreateRequest) -> Self {
6093        Self {
6094            id: ::fidl_next::FromWire::from_wire(wire.id),
6095
6096            receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
6097        }
6098    }
6099}
6100
6101impl ::fidl_next::IntoNatural for WireCapabilityStoreDirConnectorCreateRequest {
6102    type Natural = CapabilityStoreDirConnectorCreateRequest;
6103}
6104
6105/// The wire type corresponding to [`CapabilityStoreDirConnectorCreateRequest`].
6106#[derive(Debug)]
6107#[repr(C)]
6108pub struct WireCapabilityStoreDirConnectorCreateRequest {
6109    pub id: ::fidl_next::WireU64,
6110
6111    pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
6112}
6113static_assertions::const_assert_eq!(
6114    std::mem::size_of::<WireCapabilityStoreDirConnectorCreateRequest>(),
6115    16
6116);
6117static_assertions::const_assert_eq!(
6118    std::mem::align_of::<WireCapabilityStoreDirConnectorCreateRequest>(),
6119    8
6120);
6121
6122static_assertions::const_assert_eq!(
6123    std::mem::offset_of!(WireCapabilityStoreDirConnectorCreateRequest, id),
6124    0
6125);
6126
6127static_assertions::const_assert_eq!(
6128    std::mem::offset_of!(WireCapabilityStoreDirConnectorCreateRequest, receiver),
6129    8
6130);
6131
6132unsafe impl ::fidl_next::Wire for WireCapabilityStoreDirConnectorCreateRequest {
6133    type Decoded<'de> = WireCapabilityStoreDirConnectorCreateRequest;
6134
6135    #[inline]
6136    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6137        ::fidl_next::munge! {
6138            let Self {
6139
6140                id,
6141                receiver,
6142
6143            } = &mut *out_;
6144        }
6145
6146        ::fidl_next::Wire::zero_padding(id);
6147
6148        ::fidl_next::Wire::zero_padding(receiver);
6149
6150        unsafe {
6151            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
6152        }
6153    }
6154}
6155
6156unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorCreateRequest
6157where
6158    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6159    ___D: ::fidl_next::fuchsia::HandleDecoder,
6160{
6161    fn decode(
6162        slot_: ::fidl_next::Slot<'_, Self>,
6163        decoder_: &mut ___D,
6164    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6165        ::fidl_next::munge! {
6166            let Self {
6167
6168                mut id,
6169                mut receiver,
6170
6171            } = slot_;
6172        }
6173
6174        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6175
6176        ::fidl_next::Decode::decode(receiver.as_mut(), decoder_)?;
6177
6178        Ok(())
6179    }
6180}
6181
6182#[derive(PartialEq, Debug)]
6183pub struct CapabilityStoreDirConnectorOpenRequest {
6184    pub id: u64,
6185
6186    pub server_end: ::fidl_next::ServerEnd<
6187        ::fidl_next_fuchsia_io::Directory,
6188        ::fidl_next::fuchsia::zx::Channel,
6189    >,
6190}
6191
6192impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest {
6193    type Encoded = WireCapabilityStoreDirConnectorOpenRequest;
6194}
6195
6196unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenRequest
6197where
6198    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6199    ___E: ::fidl_next::fuchsia::HandleEncoder,
6200{
6201    #[inline]
6202    fn encode(
6203        self,
6204        encoder_: &mut ___E,
6205        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6206    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6207        ::fidl_next::munge! {
6208            let Self::Encoded {
6209                id,
6210                server_end,
6211
6212            } = out_;
6213        }
6214
6215        ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6216
6217        ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
6218
6219        Ok(())
6220    }
6221}
6222
6223impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenRequest {
6224    type EncodedOption = ::fidl_next::WireBox<'static, WireCapabilityStoreDirConnectorOpenRequest>;
6225}
6226
6227unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenRequest
6228where
6229    ___E: ::fidl_next::Encoder + ?Sized,
6230    CapabilityStoreDirConnectorOpenRequest: ::fidl_next::Encode<___E>,
6231{
6232    #[inline]
6233    fn encode_option(
6234        this: ::core::option::Option<Self>,
6235        encoder: &mut ___E,
6236        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6237    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6238        if let Some(inner) = this {
6239            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6240            ::fidl_next::WireBox::encode_present(out);
6241        } else {
6242            ::fidl_next::WireBox::encode_absent(out);
6243        }
6244
6245        Ok(())
6246    }
6247}
6248
6249impl ::fidl_next::FromWire<WireCapabilityStoreDirConnectorOpenRequest>
6250    for CapabilityStoreDirConnectorOpenRequest
6251{
6252    #[inline]
6253    fn from_wire(wire: WireCapabilityStoreDirConnectorOpenRequest) -> Self {
6254        Self {
6255            id: ::fidl_next::FromWire::from_wire(wire.id),
6256
6257            server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
6258        }
6259    }
6260}
6261
6262impl ::fidl_next::IntoNatural for WireCapabilityStoreDirConnectorOpenRequest {
6263    type Natural = CapabilityStoreDirConnectorOpenRequest;
6264}
6265
6266/// The wire type corresponding to [`CapabilityStoreDirConnectorOpenRequest`].
6267#[derive(Debug)]
6268#[repr(C)]
6269pub struct WireCapabilityStoreDirConnectorOpenRequest {
6270    pub id: ::fidl_next::WireU64,
6271
6272    pub server_end: ::fidl_next::ServerEnd<
6273        ::fidl_next_fuchsia_io::Directory,
6274        ::fidl_next::fuchsia::WireChannel,
6275    >,
6276}
6277static_assertions::const_assert_eq!(
6278    std::mem::size_of::<WireCapabilityStoreDirConnectorOpenRequest>(),
6279    16
6280);
6281static_assertions::const_assert_eq!(
6282    std::mem::align_of::<WireCapabilityStoreDirConnectorOpenRequest>(),
6283    8
6284);
6285
6286static_assertions::const_assert_eq!(
6287    std::mem::offset_of!(WireCapabilityStoreDirConnectorOpenRequest, id),
6288    0
6289);
6290
6291static_assertions::const_assert_eq!(
6292    std::mem::offset_of!(WireCapabilityStoreDirConnectorOpenRequest, server_end),
6293    8
6294);
6295
6296unsafe impl ::fidl_next::Wire for WireCapabilityStoreDirConnectorOpenRequest {
6297    type Decoded<'de> = WireCapabilityStoreDirConnectorOpenRequest;
6298
6299    #[inline]
6300    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6301        ::fidl_next::munge! {
6302            let Self {
6303
6304                id,
6305                server_end,
6306
6307            } = &mut *out_;
6308        }
6309
6310        ::fidl_next::Wire::zero_padding(id);
6311
6312        ::fidl_next::Wire::zero_padding(server_end);
6313
6314        unsafe {
6315            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
6316        }
6317    }
6318}
6319
6320unsafe impl<___D> ::fidl_next::Decode<___D> for WireCapabilityStoreDirConnectorOpenRequest
6321where
6322    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6323    ___D: ::fidl_next::fuchsia::HandleDecoder,
6324{
6325    fn decode(
6326        slot_: ::fidl_next::Slot<'_, Self>,
6327        decoder_: &mut ___D,
6328    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6329        ::fidl_next::munge! {
6330            let Self {
6331
6332                mut id,
6333                mut server_end,
6334
6335            } = slot_;
6336        }
6337
6338        ::fidl_next::Decode::decode(id.as_mut(), decoder_)?;
6339
6340        ::fidl_next::Decode::decode(server_end.as_mut(), decoder_)?;
6341
6342        Ok(())
6343    }
6344}
6345
6346/// The type corresponding to the CapabilityStore protocol.
6347#[doc = " Protocol that represents the concept of a \"capability store\", a repository\n for [Capability]s that are held by the component framework runtime.\n\n [CapabilityStore] serves as the main bridge between the component runtime and clients\n that enables them to operate on and exchange [Capability]s. A [CapabilityStore] instance\n contains a set of [Capability]s, each of which has a [CapabilityId] assigned by the client.\n\n Normally, a program would not exchange a [CapabilityStore] or [CapabilityId] with other\n programs -- a [CapabilityStore] connection and its enclosed capabilities are intended to\n be \"local\" to a program. Instead, if a program wishes to exchange a [Capability] with other\n programs, it should [Export] the [Capability] out of the store, send the [Capability] to the\n target program, which can then [Import] the capability into its own store.\n\n [CapabilityStore] is also used to manage capability lifetimes. The lifetime of a capability is\n scoped to the [CapabilityStore] in which it resides; i.e. to drop the [CapabilityStore]\n connections to release the capabilities instead it. In addition, [CapabilityStore] supports a\n [Drop] API to drop an individual [Capability] reference. (Note that it is possible for a\n some capabilities, like [DictionaryRef], to have multiple references, in which case all of\n the references must be dropped for the underlying resource to be released.)\n\n A note about semantics: the [CapabilityStore] APIs do not return [CapabilityId]s, because\n [CapabilityId]s are assigned by the client. Instead, when a method would semantically return\n a capability, this is expressed by taking the destination [CapabilityId] as an output parameter.\n"]
6348#[derive(PartialEq, Debug)]
6349pub struct CapabilityStore;
6350
6351impl ::fidl_next::Discoverable for CapabilityStore {
6352    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
6353}
6354
6355pub mod capability_store {
6356    pub mod prelude {
6357        pub use crate::{
6358            CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
6359            capability_store,
6360        };
6361
6362        pub use crate::CapabilityStoreConnectorCreateRequest;
6363
6364        pub use crate::CapabilityStoreConnectorOpenRequest;
6365
6366        pub use crate::CapabilityStoreDictionaryCopyRequest;
6367
6368        pub use crate::CapabilityStoreDictionaryCreateRequest;
6369
6370        pub use crate::CapabilityStoreDictionaryDrainRequest;
6371
6372        pub use crate::CapabilityStoreDictionaryEnumerateRequest;
6373
6374        pub use crate::CapabilityStoreDictionaryGetRequest;
6375
6376        pub use crate::CapabilityStoreDictionaryInsertRequest;
6377
6378        pub use crate::CapabilityStoreDictionaryKeysRequest;
6379
6380        pub use crate::CapabilityStoreDictionaryLegacyExportRequest;
6381
6382        pub use crate::CapabilityStoreDictionaryLegacyImportRequest;
6383
6384        pub use crate::CapabilityStoreDictionaryRemoveRequest;
6385
6386        pub use crate::CapabilityStoreDirConnectorCreateRequest;
6387
6388        pub use crate::CapabilityStoreDirConnectorOpenRequest;
6389
6390        pub use crate::CapabilityStoreDropRequest;
6391
6392        pub use crate::CapabilityStoreDuplicateRequest;
6393
6394        pub use crate::CapabilityStoreError;
6395
6396        pub use crate::CapabilityStoreExportRequest;
6397
6398        pub use crate::CapabilityStoreImportRequest;
6399
6400        pub use crate::CapabilityStoreConnectorCreateResponse;
6401
6402        pub use crate::CapabilityStoreConnectorOpenResponse;
6403
6404        pub use crate::CapabilityStoreDictionaryCopyResponse;
6405
6406        pub use crate::CapabilityStoreDictionaryCreateResponse;
6407
6408        pub use crate::CapabilityStoreDictionaryDrainResponse;
6409
6410        pub use crate::CapabilityStoreDictionaryEnumerateResponse;
6411
6412        pub use crate::CapabilityStoreDictionaryGetResponse;
6413
6414        pub use crate::CapabilityStoreDictionaryInsertResponse;
6415
6416        pub use crate::CapabilityStoreDictionaryKeysResponse;
6417
6418        pub use crate::CapabilityStoreDictionaryLegacyExportResponse;
6419
6420        pub use crate::CapabilityStoreDictionaryLegacyImportResponse;
6421
6422        pub use crate::CapabilityStoreDictionaryRemoveResponse;
6423
6424        pub use crate::CapabilityStoreDirConnectorCreateResponse;
6425
6426        pub use crate::CapabilityStoreDirConnectorOpenResponse;
6427
6428        pub use crate::CapabilityStoreDropResponse;
6429
6430        pub use crate::CapabilityStoreDuplicateResponse;
6431
6432        pub use crate::CapabilityStoreExportResponse;
6433
6434        pub use crate::CapabilityStoreImportResponse;
6435    }
6436
6437    pub struct Duplicate;
6438
6439    impl ::fidl_next::Method for Duplicate {
6440        const ORDINAL: u64 = 6727592627741008260;
6441
6442        type Protocol = crate::CapabilityStore;
6443
6444        type Request = crate::WireCapabilityStoreDuplicateRequest;
6445
6446        type Response = ::fidl_next::WireFlexibleResult<
6447            'static,
6448            crate::WireCapabilityStoreDuplicateResponse,
6449            crate::WireCapabilityStoreError,
6450        >;
6451    }
6452
6453    pub struct Drop;
6454
6455    impl ::fidl_next::Method for Drop {
6456        const ORDINAL: u64 = 753328233834620249;
6457
6458        type Protocol = crate::CapabilityStore;
6459
6460        type Request = crate::WireCapabilityStoreDropRequest;
6461
6462        type Response = ::fidl_next::WireFlexibleResult<
6463            'static,
6464            crate::WireCapabilityStoreDropResponse,
6465            crate::WireCapabilityStoreError,
6466        >;
6467    }
6468
6469    pub struct Export;
6470
6471    impl ::fidl_next::Method for Export {
6472        const ORDINAL: u64 = 226159162093533951;
6473
6474        type Protocol = crate::CapabilityStore;
6475
6476        type Request = crate::WireCapabilityStoreExportRequest;
6477
6478        type Response = ::fidl_next::WireFlexibleResult<
6479            'static,
6480            crate::WireCapabilityStoreExportResponse<'static>,
6481            crate::WireCapabilityStoreError,
6482        >;
6483    }
6484
6485    pub struct Import;
6486
6487    impl ::fidl_next::Method for Import {
6488        const ORDINAL: u64 = 2276030276116435867;
6489
6490        type Protocol = crate::CapabilityStore;
6491
6492        type Request = crate::WireCapabilityStoreImportRequest<'static>;
6493
6494        type Response = ::fidl_next::WireFlexibleResult<
6495            'static,
6496            crate::WireCapabilityStoreImportResponse,
6497            crate::WireCapabilityStoreError,
6498        >;
6499    }
6500
6501    pub struct ConnectorCreate;
6502
6503    impl ::fidl_next::Method for ConnectorCreate {
6504        const ORDINAL: u64 = 2979461408102095909;
6505
6506        type Protocol = crate::CapabilityStore;
6507
6508        type Request = crate::WireCapabilityStoreConnectorCreateRequest;
6509
6510        type Response = ::fidl_next::WireFlexibleResult<
6511            'static,
6512            crate::WireCapabilityStoreConnectorCreateResponse,
6513            crate::WireCapabilityStoreError,
6514        >;
6515    }
6516
6517    pub struct ConnectorOpen;
6518
6519    impl ::fidl_next::Method for ConnectorOpen {
6520        const ORDINAL: u64 = 6016362336453278623;
6521
6522        type Protocol = crate::CapabilityStore;
6523
6524        type Request = crate::WireCapabilityStoreConnectorOpenRequest;
6525
6526        type Response = ::fidl_next::WireFlexibleResult<
6527            'static,
6528            crate::WireCapabilityStoreConnectorOpenResponse,
6529            crate::WireCapabilityStoreError,
6530        >;
6531    }
6532
6533    pub struct DirConnectorCreate;
6534
6535    impl ::fidl_next::Method for DirConnectorCreate {
6536        const ORDINAL: u64 = 1756747594275428795;
6537
6538        type Protocol = crate::CapabilityStore;
6539
6540        type Request = crate::WireCapabilityStoreDirConnectorCreateRequest;
6541
6542        type Response = ::fidl_next::WireFlexibleResult<
6543            'static,
6544            crate::WireCapabilityStoreDirConnectorCreateResponse,
6545            crate::WireCapabilityStoreError,
6546        >;
6547    }
6548
6549    pub struct DirConnectorOpen;
6550
6551    impl ::fidl_next::Method for DirConnectorOpen {
6552        const ORDINAL: u64 = 6219704004220369153;
6553
6554        type Protocol = crate::CapabilityStore;
6555
6556        type Request = crate::WireCapabilityStoreDirConnectorOpenRequest;
6557
6558        type Response = ::fidl_next::WireFlexibleResult<
6559            'static,
6560            crate::WireCapabilityStoreDirConnectorOpenResponse,
6561            crate::WireCapabilityStoreError,
6562        >;
6563    }
6564
6565    pub struct DictionaryCreate;
6566
6567    impl ::fidl_next::Method for DictionaryCreate {
6568        const ORDINAL: u64 = 7608770958894948499;
6569
6570        type Protocol = crate::CapabilityStore;
6571
6572        type Request = crate::WireCapabilityStoreDictionaryCreateRequest;
6573
6574        type Response = ::fidl_next::WireFlexibleResult<
6575            'static,
6576            crate::WireCapabilityStoreDictionaryCreateResponse,
6577            crate::WireCapabilityStoreError,
6578        >;
6579    }
6580
6581    pub struct DictionaryLegacyImport;
6582
6583    impl ::fidl_next::Method for DictionaryLegacyImport {
6584        const ORDINAL: u64 = 8285893703432012383;
6585
6586        type Protocol = crate::CapabilityStore;
6587
6588        type Request = crate::WireCapabilityStoreDictionaryLegacyImportRequest;
6589
6590        type Response = ::fidl_next::WireFlexibleResult<
6591            'static,
6592            crate::WireCapabilityStoreDictionaryLegacyImportResponse,
6593            crate::WireCapabilityStoreError,
6594        >;
6595    }
6596
6597    pub struct DictionaryLegacyExport;
6598
6599    impl ::fidl_next::Method for DictionaryLegacyExport {
6600        const ORDINAL: u64 = 4647175832683306445;
6601
6602        type Protocol = crate::CapabilityStore;
6603
6604        type Request = crate::WireCapabilityStoreDictionaryLegacyExportRequest;
6605
6606        type Response = ::fidl_next::WireFlexibleResult<
6607            'static,
6608            crate::WireCapabilityStoreDictionaryLegacyExportResponse,
6609            crate::WireCapabilityStoreError,
6610        >;
6611    }
6612
6613    pub struct DictionaryInsert;
6614
6615    impl ::fidl_next::Method for DictionaryInsert {
6616        const ORDINAL: u64 = 8575443262986538023;
6617
6618        type Protocol = crate::CapabilityStore;
6619
6620        type Request = crate::WireCapabilityStoreDictionaryInsertRequest<'static>;
6621
6622        type Response = ::fidl_next::WireFlexibleResult<
6623            'static,
6624            crate::WireCapabilityStoreDictionaryInsertResponse,
6625            crate::WireCapabilityStoreError,
6626        >;
6627    }
6628
6629    pub struct DictionaryGet;
6630
6631    impl ::fidl_next::Method for DictionaryGet {
6632        const ORDINAL: u64 = 5592951026866236882;
6633
6634        type Protocol = crate::CapabilityStore;
6635
6636        type Request = crate::WireCapabilityStoreDictionaryGetRequest<'static>;
6637
6638        type Response = ::fidl_next::WireFlexibleResult<
6639            'static,
6640            crate::WireCapabilityStoreDictionaryGetResponse,
6641            crate::WireCapabilityStoreError,
6642        >;
6643    }
6644
6645    pub struct DictionaryRemove;
6646
6647    impl ::fidl_next::Method for DictionaryRemove {
6648        const ORDINAL: u64 = 343892214579320051;
6649
6650        type Protocol = crate::CapabilityStore;
6651
6652        type Request = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>;
6653
6654        type Response = ::fidl_next::WireFlexibleResult<
6655            'static,
6656            crate::WireCapabilityStoreDictionaryRemoveResponse,
6657            crate::WireCapabilityStoreError,
6658        >;
6659    }
6660
6661    pub struct DictionaryCopy;
6662
6663    impl ::fidl_next::Method for DictionaryCopy {
6664        const ORDINAL: u64 = 3977783339739362383;
6665
6666        type Protocol = crate::CapabilityStore;
6667
6668        type Request = crate::WireCapabilityStoreDictionaryCopyRequest;
6669
6670        type Response = ::fidl_next::WireFlexibleResult<
6671            'static,
6672            crate::WireCapabilityStoreDictionaryCopyResponse,
6673            crate::WireCapabilityStoreError,
6674        >;
6675    }
6676
6677    pub struct DictionaryKeys;
6678
6679    impl ::fidl_next::Method for DictionaryKeys {
6680        const ORDINAL: u64 = 597577248872787102;
6681
6682        type Protocol = crate::CapabilityStore;
6683
6684        type Request = crate::WireCapabilityStoreDictionaryKeysRequest;
6685
6686        type Response = ::fidl_next::WireFlexibleResult<
6687            'static,
6688            crate::WireCapabilityStoreDictionaryKeysResponse,
6689            crate::WireCapabilityStoreError,
6690        >;
6691    }
6692
6693    pub struct DictionaryEnumerate;
6694
6695    impl ::fidl_next::Method for DictionaryEnumerate {
6696        const ORDINAL: u64 = 964467096271472193;
6697
6698        type Protocol = crate::CapabilityStore;
6699
6700        type Request = crate::WireCapabilityStoreDictionaryEnumerateRequest;
6701
6702        type Response = ::fidl_next::WireFlexibleResult<
6703            'static,
6704            crate::WireCapabilityStoreDictionaryEnumerateResponse,
6705            crate::WireCapabilityStoreError,
6706        >;
6707    }
6708
6709    pub struct DictionaryDrain;
6710
6711    impl ::fidl_next::Method for DictionaryDrain {
6712        const ORDINAL: u64 = 2928364469569621208;
6713
6714        type Protocol = crate::CapabilityStore;
6715
6716        type Request = crate::WireCapabilityStoreDictionaryDrainRequest;
6717
6718        type Response = ::fidl_next::WireFlexibleResult<
6719            'static,
6720            crate::WireCapabilityStoreDictionaryDrainResponse,
6721            crate::WireCapabilityStoreError,
6722        >;
6723    }
6724
6725    mod ___detail {
6726
6727        pub struct Duplicate<T0, T1> {
6728            id: T0,
6729
6730            dest_id: T1,
6731        }
6732
6733        impl<T0, T1> ::fidl_next::Encodable for Duplicate<T0, T1>
6734        where
6735            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6736            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6737        {
6738            type Encoded = crate::WireCapabilityStoreDuplicateRequest;
6739        }
6740
6741        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Duplicate<T0, T1>
6742        where
6743            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6744            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6745            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6746        {
6747            #[inline]
6748            fn encode(
6749                self,
6750                encoder_: &mut ___E,
6751                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6752            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6753                ::fidl_next::munge! {
6754                    let Self::Encoded {
6755                        id,
6756                        dest_id,
6757
6758                    } = out_;
6759                }
6760
6761                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6762
6763                ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
6764
6765                Ok(())
6766            }
6767        }
6768
6769        pub struct Drop<T0> {
6770            id: T0,
6771        }
6772
6773        impl<T0> ::fidl_next::Encodable for Drop<T0>
6774        where
6775            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6776        {
6777            type Encoded = crate::WireCapabilityStoreDropRequest;
6778        }
6779
6780        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Drop<T0>
6781        where
6782            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6783            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6784        {
6785            #[inline]
6786            fn encode(
6787                self,
6788                encoder_: &mut ___E,
6789                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6790            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6791                ::fidl_next::munge! {
6792                    let Self::Encoded {
6793                        id,
6794
6795                    } = out_;
6796                }
6797
6798                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6799
6800                Ok(())
6801            }
6802        }
6803
6804        pub struct Export<T0> {
6805            id: T0,
6806        }
6807
6808        impl<T0> ::fidl_next::Encodable for Export<T0>
6809        where
6810            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6811        {
6812            type Encoded = crate::WireCapabilityStoreExportRequest;
6813        }
6814
6815        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Export<T0>
6816        where
6817            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6818            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6819        {
6820            #[inline]
6821            fn encode(
6822                self,
6823                encoder_: &mut ___E,
6824                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6825            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6826                ::fidl_next::munge! {
6827                    let Self::Encoded {
6828                        id,
6829
6830                    } = out_;
6831                }
6832
6833                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6834
6835                Ok(())
6836            }
6837        }
6838
6839        pub struct Import<T0, T1> {
6840            id: T0,
6841
6842            capability: T1,
6843        }
6844
6845        impl<T0, T1> ::fidl_next::Encodable for Import<T0, T1>
6846        where
6847            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6848            T1: ::fidl_next::Encodable<Encoded = crate::WireCapability<'static>>,
6849        {
6850            type Encoded = crate::WireCapabilityStoreImportRequest<'static>;
6851        }
6852
6853        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Import<T0, T1>
6854        where
6855            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6856            ___E: ::fidl_next::Encoder,
6857            ___E: ::fidl_next::fuchsia::HandleEncoder,
6858            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6859            T1: ::fidl_next::Encode<___E, Encoded = crate::WireCapability<'static>>,
6860        {
6861            #[inline]
6862            fn encode(
6863                self,
6864                encoder_: &mut ___E,
6865                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6866            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6867                ::fidl_next::munge! {
6868                    let Self::Encoded {
6869                        id,
6870                        capability,
6871
6872                    } = out_;
6873                }
6874
6875                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6876
6877                ::fidl_next::Encode::encode(self.capability, encoder_, capability)?;
6878
6879                Ok(())
6880            }
6881        }
6882
6883        pub struct ConnectorCreate<T0, T1> {
6884            id: T0,
6885
6886            receiver: T1,
6887        }
6888
6889        impl<T0, T1> ::fidl_next::Encodable for ConnectorCreate<T0, T1>
6890        where
6891            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6892            T1: ::fidl_next::Encodable<
6893                    Encoded = ::fidl_next::ClientEnd<
6894                        crate::Receiver,
6895                        ::fidl_next::fuchsia::WireChannel,
6896                    >,
6897                >,
6898        {
6899            type Encoded = crate::WireCapabilityStoreConnectorCreateRequest;
6900        }
6901
6902        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for ConnectorCreate<T0, T1>
6903        where
6904            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6905            ___E: ::fidl_next::fuchsia::HandleEncoder,
6906            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6907            T1: ::fidl_next::Encode<
6908                    ___E,
6909                    Encoded = ::fidl_next::ClientEnd<
6910                        crate::Receiver,
6911                        ::fidl_next::fuchsia::WireChannel,
6912                    >,
6913                >,
6914        {
6915            #[inline]
6916            fn encode(
6917                self,
6918                encoder_: &mut ___E,
6919                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6920            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6921                ::fidl_next::munge! {
6922                    let Self::Encoded {
6923                        id,
6924                        receiver,
6925
6926                    } = out_;
6927                }
6928
6929                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6930
6931                ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
6932
6933                Ok(())
6934            }
6935        }
6936
6937        pub struct ConnectorOpen<T0, T1> {
6938            id: T0,
6939
6940            server_end: T1,
6941        }
6942
6943        impl<T0, T1> ::fidl_next::Encodable for ConnectorOpen<T0, T1>
6944        where
6945            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6946            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
6947        {
6948            type Encoded = crate::WireCapabilityStoreConnectorOpenRequest;
6949        }
6950
6951        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for ConnectorOpen<T0, T1>
6952        where
6953            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6954            ___E: ::fidl_next::fuchsia::HandleEncoder,
6955            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
6956            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
6957        {
6958            #[inline]
6959            fn encode(
6960                self,
6961                encoder_: &mut ___E,
6962                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6963            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6964                ::fidl_next::munge! {
6965                    let Self::Encoded {
6966                        id,
6967                        server_end,
6968
6969                    } = out_;
6970                }
6971
6972                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
6973
6974                ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
6975
6976                Ok(())
6977            }
6978        }
6979
6980        pub struct DirConnectorCreate<T0, T1> {
6981            id: T0,
6982
6983            receiver: T1,
6984        }
6985
6986        impl<T0, T1> ::fidl_next::Encodable for DirConnectorCreate<T0, T1>
6987        where
6988            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
6989            T1: ::fidl_next::Encodable<
6990                    Encoded = ::fidl_next::ClientEnd<
6991                        crate::DirReceiver,
6992                        ::fidl_next::fuchsia::WireChannel,
6993                    >,
6994                >,
6995        {
6996            type Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest;
6997        }
6998
6999        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DirConnectorCreate<T0, T1>
7000        where
7001            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7002            ___E: ::fidl_next::fuchsia::HandleEncoder,
7003            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7004            T1: ::fidl_next::Encode<
7005                    ___E,
7006                    Encoded = ::fidl_next::ClientEnd<
7007                        crate::DirReceiver,
7008                        ::fidl_next::fuchsia::WireChannel,
7009                    >,
7010                >,
7011        {
7012            #[inline]
7013            fn encode(
7014                self,
7015                encoder_: &mut ___E,
7016                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7017            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7018                ::fidl_next::munge! {
7019                    let Self::Encoded {
7020                        id,
7021                        receiver,
7022
7023                    } = out_;
7024                }
7025
7026                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7027
7028                ::fidl_next::Encode::encode(self.receiver, encoder_, receiver)?;
7029
7030                Ok(())
7031            }
7032        }
7033
7034        pub struct DirConnectorOpen<T0, T1> {
7035            id: T0,
7036
7037            server_end: T1,
7038        }
7039
7040        impl<T0, T1> ::fidl_next::Encodable for DirConnectorOpen<T0, T1>
7041        where
7042            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7043            T1: ::fidl_next::Encodable<
7044                    Encoded = ::fidl_next::ServerEnd<
7045                        ::fidl_next_fuchsia_io::Directory,
7046                        ::fidl_next::fuchsia::WireChannel,
7047                    >,
7048                >,
7049        {
7050            type Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest;
7051        }
7052
7053        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DirConnectorOpen<T0, T1>
7054        where
7055            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7056            ___E: ::fidl_next::fuchsia::HandleEncoder,
7057            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7058            T1: ::fidl_next::Encode<
7059                    ___E,
7060                    Encoded = ::fidl_next::ServerEnd<
7061                        ::fidl_next_fuchsia_io::Directory,
7062                        ::fidl_next::fuchsia::WireChannel,
7063                    >,
7064                >,
7065        {
7066            #[inline]
7067            fn encode(
7068                self,
7069                encoder_: &mut ___E,
7070                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7071            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7072                ::fidl_next::munge! {
7073                    let Self::Encoded {
7074                        id,
7075                        server_end,
7076
7077                    } = out_;
7078                }
7079
7080                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7081
7082                ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
7083
7084                Ok(())
7085            }
7086        }
7087
7088        pub struct DictionaryCreate<T0> {
7089            id: T0,
7090        }
7091
7092        impl<T0> ::fidl_next::Encodable for DictionaryCreate<T0>
7093        where
7094            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7095        {
7096            type Encoded = crate::WireCapabilityStoreDictionaryCreateRequest;
7097        }
7098
7099        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryCreate<T0>
7100        where
7101            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7102            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7103        {
7104            #[inline]
7105            fn encode(
7106                self,
7107                encoder_: &mut ___E,
7108                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7109            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7110                ::fidl_next::munge! {
7111                    let Self::Encoded {
7112                        id,
7113
7114                    } = out_;
7115                }
7116
7117                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7118
7119                Ok(())
7120            }
7121        }
7122
7123        pub struct DictionaryLegacyImport<T0, T1> {
7124            id: T0,
7125
7126            client_end: T1,
7127        }
7128
7129        impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyImport<T0, T1>
7130        where
7131            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7132            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
7133        {
7134            type Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest;
7135        }
7136
7137        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryLegacyImport<T0, T1>
7138        where
7139            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7140            ___E: ::fidl_next::fuchsia::HandleEncoder,
7141            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7142            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
7143        {
7144            #[inline]
7145            fn encode(
7146                self,
7147                encoder_: &mut ___E,
7148                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7149            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7150                ::fidl_next::munge! {
7151                    let Self::Encoded {
7152                        id,
7153                        client_end,
7154
7155                    } = out_;
7156                }
7157
7158                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7159
7160                ::fidl_next::Encode::encode(self.client_end, encoder_, client_end)?;
7161
7162                Ok(())
7163            }
7164        }
7165
7166        pub struct DictionaryLegacyExport<T0, T1> {
7167            id: T0,
7168
7169            server_end: T1,
7170        }
7171
7172        impl<T0, T1> ::fidl_next::Encodable for DictionaryLegacyExport<T0, T1>
7173        where
7174            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7175            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
7176        {
7177            type Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest;
7178        }
7179
7180        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryLegacyExport<T0, T1>
7181        where
7182            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7183            ___E: ::fidl_next::fuchsia::HandleEncoder,
7184            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7185            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
7186        {
7187            #[inline]
7188            fn encode(
7189                self,
7190                encoder_: &mut ___E,
7191                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7192            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7193                ::fidl_next::munge! {
7194                    let Self::Encoded {
7195                        id,
7196                        server_end,
7197
7198                    } = out_;
7199                }
7200
7201                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7202
7203                ::fidl_next::Encode::encode(self.server_end, encoder_, server_end)?;
7204
7205                Ok(())
7206            }
7207        }
7208
7209        pub struct DictionaryInsert<T0, T1> {
7210            id: T0,
7211
7212            item: T1,
7213        }
7214
7215        impl<T0, T1> ::fidl_next::Encodable for DictionaryInsert<T0, T1>
7216        where
7217            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7218            T1: ::fidl_next::Encodable<Encoded = crate::WireDictionaryItem<'static>>,
7219        {
7220            type Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>;
7221        }
7222
7223        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryInsert<T0, T1>
7224        where
7225            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7226            ___E: ::fidl_next::Encoder,
7227            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7228            T1: ::fidl_next::Encode<___E, Encoded = crate::WireDictionaryItem<'static>>,
7229        {
7230            #[inline]
7231            fn encode(
7232                self,
7233                encoder_: &mut ___E,
7234                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7235            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7236                ::fidl_next::munge! {
7237                    let Self::Encoded {
7238                        id,
7239                        item,
7240
7241                    } = out_;
7242                }
7243
7244                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7245
7246                ::fidl_next::Encode::encode(self.item, encoder_, item)?;
7247
7248                Ok(())
7249            }
7250        }
7251
7252        pub struct DictionaryGet<T0, T1, T2> {
7253            id: T0,
7254
7255            key: T1,
7256
7257            dest_id: T2,
7258        }
7259
7260        impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryGet<T0, T1, T2>
7261        where
7262            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7263            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
7264            T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7265        {
7266            type Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>;
7267        }
7268
7269        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for DictionaryGet<T0, T1, T2>
7270        where
7271            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7272            ___E: ::fidl_next::Encoder,
7273            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7274            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
7275            T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7276        {
7277            #[inline]
7278            fn encode(
7279                self,
7280                encoder_: &mut ___E,
7281                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7282            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7283                ::fidl_next::munge! {
7284                    let Self::Encoded {
7285                        id,
7286                        key,
7287                        dest_id,
7288
7289                    } = out_;
7290                }
7291
7292                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7293
7294                ::fidl_next::Encode::encode(self.key, encoder_, key)?;
7295
7296                ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7297
7298                Ok(())
7299            }
7300        }
7301
7302        pub struct DictionaryRemove<T0, T1, T2> {
7303            id: T0,
7304
7305            key: T1,
7306
7307            dest_id: T2,
7308        }
7309
7310        impl<T0, T1, T2> ::fidl_next::Encodable for DictionaryRemove<T0, T1, T2>
7311        where
7312            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7313            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
7314            T2: ::fidl_next::Encodable<
7315                    Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
7316                >,
7317        {
7318            type Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>;
7319        }
7320
7321        unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E> for DictionaryRemove<T0, T1, T2>
7322        where
7323            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7324            ___E: ::fidl_next::Encoder,
7325            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7326            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
7327            T2: ::fidl_next::Encode<
7328                    ___E,
7329                    Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
7330                >,
7331        {
7332            #[inline]
7333            fn encode(
7334                self,
7335                encoder_: &mut ___E,
7336                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7337            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7338                ::fidl_next::munge! {
7339                    let Self::Encoded {
7340                        id,
7341                        key,
7342                        dest_id,
7343
7344                    } = out_;
7345                }
7346
7347                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7348
7349                ::fidl_next::Encode::encode(self.key, encoder_, key)?;
7350
7351                ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7352
7353                Ok(())
7354            }
7355        }
7356
7357        pub struct DictionaryCopy<T0, T1> {
7358            id: T0,
7359
7360            dest_id: T1,
7361        }
7362
7363        impl<T0, T1> ::fidl_next::Encodable for DictionaryCopy<T0, T1>
7364        where
7365            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7366            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7367        {
7368            type Encoded = crate::WireCapabilityStoreDictionaryCopyRequest;
7369        }
7370
7371        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryCopy<T0, T1>
7372        where
7373            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7374            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7375            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7376        {
7377            #[inline]
7378            fn encode(
7379                self,
7380                encoder_: &mut ___E,
7381                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7382            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7383                ::fidl_next::munge! {
7384                    let Self::Encoded {
7385                        id,
7386                        dest_id,
7387
7388                    } = out_;
7389                }
7390
7391                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7392
7393                ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id)?;
7394
7395                Ok(())
7396            }
7397        }
7398
7399        pub struct DictionaryKeys<T0, T1> {
7400            id: T0,
7401
7402            iterator: T1,
7403        }
7404
7405        impl<T0, T1> ::fidl_next::Encodable for DictionaryKeys<T0, T1>
7406        where
7407            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7408            T1: ::fidl_next::Encodable<
7409                    Encoded = ::fidl_next::ServerEnd<
7410                        crate::DictionaryKeysIterator,
7411                        ::fidl_next::fuchsia::WireChannel,
7412                    >,
7413                >,
7414        {
7415            type Encoded = crate::WireCapabilityStoreDictionaryKeysRequest;
7416        }
7417
7418        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryKeys<T0, T1>
7419        where
7420            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7421            ___E: ::fidl_next::fuchsia::HandleEncoder,
7422            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7423            T1: ::fidl_next::Encode<
7424                    ___E,
7425                    Encoded = ::fidl_next::ServerEnd<
7426                        crate::DictionaryKeysIterator,
7427                        ::fidl_next::fuchsia::WireChannel,
7428                    >,
7429                >,
7430        {
7431            #[inline]
7432            fn encode(
7433                self,
7434                encoder_: &mut ___E,
7435                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7436            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7437                ::fidl_next::munge! {
7438                    let Self::Encoded {
7439                        id,
7440                        iterator,
7441
7442                    } = out_;
7443                }
7444
7445                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7446
7447                ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7448
7449                Ok(())
7450            }
7451        }
7452
7453        pub struct DictionaryEnumerate<T0, T1> {
7454            id: T0,
7455
7456            iterator: T1,
7457        }
7458
7459        impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerate<T0, T1>
7460        where
7461            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7462            T1: ::fidl_next::Encodable<
7463                    Encoded = ::fidl_next::ServerEnd<
7464                        crate::DictionaryEnumerateIterator,
7465                        ::fidl_next::fuchsia::WireChannel,
7466                    >,
7467                >,
7468        {
7469            type Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest;
7470        }
7471
7472        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryEnumerate<T0, T1>
7473        where
7474            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7475            ___E: ::fidl_next::fuchsia::HandleEncoder,
7476            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7477            T1: ::fidl_next::Encode<
7478                    ___E,
7479                    Encoded = ::fidl_next::ServerEnd<
7480                        crate::DictionaryEnumerateIterator,
7481                        ::fidl_next::fuchsia::WireChannel,
7482                    >,
7483                >,
7484        {
7485            #[inline]
7486            fn encode(
7487                self,
7488                encoder_: &mut ___E,
7489                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7490            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7491                ::fidl_next::munge! {
7492                    let Self::Encoded {
7493                        id,
7494                        iterator,
7495
7496                    } = out_;
7497                }
7498
7499                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7500
7501                ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7502
7503                Ok(())
7504            }
7505        }
7506
7507        pub struct DictionaryDrain<T0, T1> {
7508            id: T0,
7509
7510            iterator: T1,
7511        }
7512
7513        impl<T0, T1> ::fidl_next::Encodable for DictionaryDrain<T0, T1>
7514        where
7515            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
7516            T1: ::fidl_next::Encodable<
7517                    Encoded = ::fidl_next::ServerEnd<
7518                        crate::DictionaryDrainIterator,
7519                        ::fidl_next::fuchsia::WireOptionalChannel,
7520                    >,
7521                >,
7522        {
7523            type Encoded = crate::WireCapabilityStoreDictionaryDrainRequest;
7524        }
7525
7526        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryDrain<T0, T1>
7527        where
7528            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7529            ___E: ::fidl_next::fuchsia::HandleEncoder,
7530            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
7531            T1: ::fidl_next::Encode<
7532                    ___E,
7533                    Encoded = ::fidl_next::ServerEnd<
7534                        crate::DictionaryDrainIterator,
7535                        ::fidl_next::fuchsia::WireOptionalChannel,
7536                    >,
7537                >,
7538        {
7539            #[inline]
7540            fn encode(
7541                self,
7542                encoder_: &mut ___E,
7543                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7544            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7545                ::fidl_next::munge! {
7546                    let Self::Encoded {
7547                        id,
7548                        iterator,
7549
7550                    } = out_;
7551                }
7552
7553                ::fidl_next::Encode::encode(self.id, encoder_, id)?;
7554
7555                ::fidl_next::Encode::encode(self.iterator, encoder_, iterator)?;
7556
7557                Ok(())
7558            }
7559        }
7560
7561        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::CapabilityStore
7562        where
7563            ___T: ::fidl_next::Transport,
7564        {
7565            type Client = CapabilityStoreClient<___T>;
7566            type Server = CapabilityStoreServer<___T>;
7567        }
7568
7569        /// The client for the `CapabilityStore` protocol.
7570        #[repr(transparent)]
7571        pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
7572            #[allow(dead_code)]
7573            client: ::fidl_next::protocol::Client<___T>,
7574        }
7575
7576        impl<___T> CapabilityStoreClient<___T>
7577        where
7578            ___T: ::fidl_next::Transport,
7579        {
7580            #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
7581            pub fn duplicate(
7582                &self,
7583
7584                id: impl ::fidl_next::Encode<
7585                    <___T as ::fidl_next::Transport>::SendBuffer,
7586                    Encoded = ::fidl_next::WireU64,
7587                >,
7588
7589                dest_id: impl ::fidl_next::Encode<
7590                    <___T as ::fidl_next::Transport>::SendBuffer,
7591                    Encoded = ::fidl_next::WireU64,
7592                >,
7593            ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
7594            where
7595                <___T as ::fidl_next::Transport>::SendBuffer:
7596                    ::fidl_next::encoder::InternalHandleEncoder,
7597            {
7598                self.duplicate_with(Duplicate { id, dest_id })
7599            }
7600
7601            #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
7602            pub fn duplicate_with<___R>(
7603                &self,
7604                request: ___R,
7605            ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
7606            where
7607                ___R: ::fidl_next::Encode<
7608                        <___T as ::fidl_next::Transport>::SendBuffer,
7609                        Encoded = crate::WireCapabilityStoreDuplicateRequest,
7610                    >,
7611            {
7612                ::fidl_next::TwoWayFuture::from_untyped(
7613                    self.client.send_two_way(6727592627741008260, request),
7614                )
7615            }
7616
7617            #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7618            pub fn drop(
7619                &self,
7620
7621                id: impl ::fidl_next::Encode<
7622                    <___T as ::fidl_next::Transport>::SendBuffer,
7623                    Encoded = ::fidl_next::WireU64,
7624                >,
7625            ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
7626            where
7627                <___T as ::fidl_next::Transport>::SendBuffer:
7628                    ::fidl_next::encoder::InternalHandleEncoder,
7629            {
7630                self.drop_with(Drop { id })
7631            }
7632
7633            #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7634            pub fn drop_with<___R>(
7635                &self,
7636                request: ___R,
7637            ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
7638            where
7639                ___R: ::fidl_next::Encode<
7640                        <___T as ::fidl_next::Transport>::SendBuffer,
7641                        Encoded = crate::WireCapabilityStoreDropRequest,
7642                    >,
7643            {
7644                ::fidl_next::TwoWayFuture::from_untyped(
7645                    self.client.send_two_way(753328233834620249, request),
7646                )
7647            }
7648
7649            #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7650            pub fn export(
7651                &self,
7652
7653                id: impl ::fidl_next::Encode<
7654                    <___T as ::fidl_next::Transport>::SendBuffer,
7655                    Encoded = ::fidl_next::WireU64,
7656                >,
7657            ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
7658            where
7659                <___T as ::fidl_next::Transport>::SendBuffer:
7660                    ::fidl_next::encoder::InternalHandleEncoder,
7661            {
7662                self.export_with(Export { id })
7663            }
7664
7665            #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7666            pub fn export_with<___R>(
7667                &self,
7668                request: ___R,
7669            ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
7670            where
7671                ___R: ::fidl_next::Encode<
7672                        <___T as ::fidl_next::Transport>::SendBuffer,
7673                        Encoded = crate::WireCapabilityStoreExportRequest,
7674                    >,
7675            {
7676                ::fidl_next::TwoWayFuture::from_untyped(
7677                    self.client.send_two_way(226159162093533951, request),
7678                )
7679            }
7680
7681            #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
7682            pub fn import(
7683                &self,
7684
7685                id: impl ::fidl_next::Encode<
7686                    <___T as ::fidl_next::Transport>::SendBuffer,
7687                    Encoded = ::fidl_next::WireU64,
7688                >,
7689
7690                capability: impl ::fidl_next::Encode<
7691                    <___T as ::fidl_next::Transport>::SendBuffer,
7692                    Encoded = crate::WireCapability<'static>,
7693                >,
7694            ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
7695            where
7696                <___T as ::fidl_next::Transport>::SendBuffer:
7697                    ::fidl_next::encoder::InternalHandleEncoder,
7698                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7699                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7700            {
7701                self.import_with(Import { id, capability })
7702            }
7703
7704            #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
7705            pub fn import_with<___R>(
7706                &self,
7707                request: ___R,
7708            ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
7709            where
7710                ___R: ::fidl_next::Encode<
7711                        <___T as ::fidl_next::Transport>::SendBuffer,
7712                        Encoded = crate::WireCapabilityStoreImportRequest<'static>,
7713                    >,
7714            {
7715                ::fidl_next::TwoWayFuture::from_untyped(
7716                    self.client.send_two_way(2276030276116435867, request),
7717                )
7718            }
7719
7720            #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7721            pub fn connector_create(
7722                &self,
7723
7724                id: impl ::fidl_next::Encode<
7725                    <___T as ::fidl_next::Transport>::SendBuffer,
7726                    Encoded = ::fidl_next::WireU64,
7727                >,
7728
7729                receiver: impl ::fidl_next::Encode<
7730                    <___T as ::fidl_next::Transport>::SendBuffer,
7731                    Encoded = ::fidl_next::ClientEnd<
7732                        crate::Receiver,
7733                        ::fidl_next::fuchsia::WireChannel,
7734                    >,
7735                >,
7736            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
7737            where
7738                <___T as ::fidl_next::Transport>::SendBuffer:
7739                    ::fidl_next::encoder::InternalHandleEncoder,
7740                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7741            {
7742                self.connector_create_with(ConnectorCreate { id, receiver })
7743            }
7744
7745            #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7746            pub fn connector_create_with<___R>(
7747                &self,
7748                request: ___R,
7749            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
7750            where
7751                ___R: ::fidl_next::Encode<
7752                        <___T as ::fidl_next::Transport>::SendBuffer,
7753                        Encoded = crate::WireCapabilityStoreConnectorCreateRequest,
7754                    >,
7755            {
7756                ::fidl_next::TwoWayFuture::from_untyped(
7757                    self.client.send_two_way(2979461408102095909, request),
7758                )
7759            }
7760
7761            #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
7762            pub fn connector_open(
7763                &self,
7764
7765                id: impl ::fidl_next::Encode<
7766                    <___T as ::fidl_next::Transport>::SendBuffer,
7767                    Encoded = ::fidl_next::WireU64,
7768                >,
7769
7770                server_end: impl ::fidl_next::Encode<
7771                    <___T as ::fidl_next::Transport>::SendBuffer,
7772                    Encoded = ::fidl_next::fuchsia::WireChannel,
7773                >,
7774            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
7775            where
7776                <___T as ::fidl_next::Transport>::SendBuffer:
7777                    ::fidl_next::encoder::InternalHandleEncoder,
7778                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7779            {
7780                self.connector_open_with(ConnectorOpen { id, server_end })
7781            }
7782
7783            #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
7784            pub fn connector_open_with<___R>(
7785                &self,
7786                request: ___R,
7787            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
7788            where
7789                ___R: ::fidl_next::Encode<
7790                        <___T as ::fidl_next::Transport>::SendBuffer,
7791                        Encoded = crate::WireCapabilityStoreConnectorOpenRequest,
7792                    >,
7793            {
7794                ::fidl_next::TwoWayFuture::from_untyped(
7795                    self.client.send_two_way(6016362336453278623, request),
7796                )
7797            }
7798
7799            #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7800            pub fn dir_connector_create(
7801                &self,
7802
7803                id: impl ::fidl_next::Encode<
7804                    <___T as ::fidl_next::Transport>::SendBuffer,
7805                    Encoded = ::fidl_next::WireU64,
7806                >,
7807
7808                receiver: impl ::fidl_next::Encode<
7809                    <___T as ::fidl_next::Transport>::SendBuffer,
7810                    Encoded = ::fidl_next::ClientEnd<
7811                        crate::DirReceiver,
7812                        ::fidl_next::fuchsia::WireChannel,
7813                    >,
7814                >,
7815            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
7816            where
7817                <___T as ::fidl_next::Transport>::SendBuffer:
7818                    ::fidl_next::encoder::InternalHandleEncoder,
7819                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7820            {
7821                self.dir_connector_create_with(DirConnectorCreate { id, receiver })
7822            }
7823
7824            #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7825            pub fn dir_connector_create_with<___R>(
7826                &self,
7827                request: ___R,
7828            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
7829            where
7830                ___R: ::fidl_next::Encode<
7831                        <___T as ::fidl_next::Transport>::SendBuffer,
7832                        Encoded = crate::WireCapabilityStoreDirConnectorCreateRequest,
7833                    >,
7834            {
7835                ::fidl_next::TwoWayFuture::from_untyped(
7836                    self.client.send_two_way(1756747594275428795, request),
7837                )
7838            }
7839
7840            #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
7841            pub fn dir_connector_open(
7842                &self,
7843
7844                id: impl ::fidl_next::Encode<
7845                    <___T as ::fidl_next::Transport>::SendBuffer,
7846                    Encoded = ::fidl_next::WireU64,
7847                >,
7848
7849                server_end: impl ::fidl_next::Encode<
7850                    <___T as ::fidl_next::Transport>::SendBuffer,
7851                    Encoded = ::fidl_next::ServerEnd<
7852                        ::fidl_next_fuchsia_io::Directory,
7853                        ::fidl_next::fuchsia::WireChannel,
7854                    >,
7855                >,
7856            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
7857            where
7858                <___T as ::fidl_next::Transport>::SendBuffer:
7859                    ::fidl_next::encoder::InternalHandleEncoder,
7860                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7861            {
7862                self.dir_connector_open_with(DirConnectorOpen { id, server_end })
7863            }
7864
7865            #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
7866            pub fn dir_connector_open_with<___R>(
7867                &self,
7868                request: ___R,
7869            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
7870            where
7871                ___R: ::fidl_next::Encode<
7872                        <___T as ::fidl_next::Transport>::SendBuffer,
7873                        Encoded = crate::WireCapabilityStoreDirConnectorOpenRequest,
7874                    >,
7875            {
7876                ::fidl_next::TwoWayFuture::from_untyped(
7877                    self.client.send_two_way(6219704004220369153, request),
7878                )
7879            }
7880
7881            #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7882            pub fn dictionary_create(
7883                &self,
7884
7885                id: impl ::fidl_next::Encode<
7886                    <___T as ::fidl_next::Transport>::SendBuffer,
7887                    Encoded = ::fidl_next::WireU64,
7888                >,
7889            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
7890            where
7891                <___T as ::fidl_next::Transport>::SendBuffer:
7892                    ::fidl_next::encoder::InternalHandleEncoder,
7893            {
7894                self.dictionary_create_with(DictionaryCreate { id })
7895            }
7896
7897            #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
7898            pub fn dictionary_create_with<___R>(
7899                &self,
7900                request: ___R,
7901            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
7902            where
7903                ___R: ::fidl_next::Encode<
7904                        <___T as ::fidl_next::Transport>::SendBuffer,
7905                        Encoded = crate::WireCapabilityStoreDictionaryCreateRequest,
7906                    >,
7907            {
7908                ::fidl_next::TwoWayFuture::from_untyped(
7909                    self.client.send_two_way(7608770958894948499, request),
7910                )
7911            }
7912
7913            #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
7914            pub fn dictionary_legacy_import(
7915                &self,
7916
7917                id: impl ::fidl_next::Encode<
7918                    <___T as ::fidl_next::Transport>::SendBuffer,
7919                    Encoded = ::fidl_next::WireU64,
7920                >,
7921
7922                client_end: impl ::fidl_next::Encode<
7923                    <___T as ::fidl_next::Transport>::SendBuffer,
7924                    Encoded = ::fidl_next::fuchsia::WireChannel,
7925                >,
7926            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
7927            where
7928                <___T as ::fidl_next::Transport>::SendBuffer:
7929                    ::fidl_next::encoder::InternalHandleEncoder,
7930                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7931            {
7932                self.dictionary_legacy_import_with(DictionaryLegacyImport { id, client_end })
7933            }
7934
7935            #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
7936            pub fn dictionary_legacy_import_with<___R>(
7937                &self,
7938                request: ___R,
7939            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
7940            where
7941                ___R: ::fidl_next::Encode<
7942                        <___T as ::fidl_next::Transport>::SendBuffer,
7943                        Encoded = crate::WireCapabilityStoreDictionaryLegacyImportRequest,
7944                    >,
7945            {
7946                ::fidl_next::TwoWayFuture::from_untyped(
7947                    self.client.send_two_way(8285893703432012383, request),
7948                )
7949            }
7950
7951            #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7952            pub fn dictionary_legacy_export(
7953                &self,
7954
7955                id: impl ::fidl_next::Encode<
7956                    <___T as ::fidl_next::Transport>::SendBuffer,
7957                    Encoded = ::fidl_next::WireU64,
7958                >,
7959
7960                server_end: impl ::fidl_next::Encode<
7961                    <___T as ::fidl_next::Transport>::SendBuffer,
7962                    Encoded = ::fidl_next::fuchsia::WireChannel,
7963                >,
7964            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
7965            where
7966                <___T as ::fidl_next::Transport>::SendBuffer:
7967                    ::fidl_next::encoder::InternalHandleEncoder,
7968                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7969            {
7970                self.dictionary_legacy_export_with(DictionaryLegacyExport { id, server_end })
7971            }
7972
7973            #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
7974            pub fn dictionary_legacy_export_with<___R>(
7975                &self,
7976                request: ___R,
7977            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
7978            where
7979                ___R: ::fidl_next::Encode<
7980                        <___T as ::fidl_next::Transport>::SendBuffer,
7981                        Encoded = crate::WireCapabilityStoreDictionaryLegacyExportRequest,
7982                    >,
7983            {
7984                ::fidl_next::TwoWayFuture::from_untyped(
7985                    self.client.send_two_way(4647175832683306445, request),
7986                )
7987            }
7988
7989            #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
7990            pub fn dictionary_insert(
7991                &self,
7992
7993                id: impl ::fidl_next::Encode<
7994                    <___T as ::fidl_next::Transport>::SendBuffer,
7995                    Encoded = ::fidl_next::WireU64,
7996                >,
7997
7998                item: impl ::fidl_next::Encode<
7999                    <___T as ::fidl_next::Transport>::SendBuffer,
8000                    Encoded = crate::WireDictionaryItem<'static>,
8001                >,
8002            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8003            where
8004                <___T as ::fidl_next::Transport>::SendBuffer:
8005                    ::fidl_next::encoder::InternalHandleEncoder,
8006                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8007            {
8008                self.dictionary_insert_with(DictionaryInsert { id, item })
8009            }
8010
8011            #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
8012            pub fn dictionary_insert_with<___R>(
8013                &self,
8014                request: ___R,
8015            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
8016            where
8017                ___R: ::fidl_next::Encode<
8018                        <___T as ::fidl_next::Transport>::SendBuffer,
8019                        Encoded = crate::WireCapabilityStoreDictionaryInsertRequest<'static>,
8020                    >,
8021            {
8022                ::fidl_next::TwoWayFuture::from_untyped(
8023                    self.client.send_two_way(8575443262986538023, request),
8024                )
8025            }
8026
8027            #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
8028            pub fn dictionary_get(
8029                &self,
8030
8031                id: impl ::fidl_next::Encode<
8032                    <___T as ::fidl_next::Transport>::SendBuffer,
8033                    Encoded = ::fidl_next::WireU64,
8034                >,
8035
8036                key: impl ::fidl_next::Encode<
8037                    <___T as ::fidl_next::Transport>::SendBuffer,
8038                    Encoded = ::fidl_next::WireString<'static>,
8039                >,
8040
8041                dest_id: impl ::fidl_next::Encode<
8042                    <___T as ::fidl_next::Transport>::SendBuffer,
8043                    Encoded = ::fidl_next::WireU64,
8044                >,
8045            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8046            where
8047                <___T as ::fidl_next::Transport>::SendBuffer:
8048                    ::fidl_next::encoder::InternalHandleEncoder,
8049                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8050            {
8051                self.dictionary_get_with(DictionaryGet { id, key, dest_id })
8052            }
8053
8054            #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
8055            pub fn dictionary_get_with<___R>(
8056                &self,
8057                request: ___R,
8058            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
8059            where
8060                ___R: ::fidl_next::Encode<
8061                        <___T as ::fidl_next::Transport>::SendBuffer,
8062                        Encoded = crate::WireCapabilityStoreDictionaryGetRequest<'static>,
8063                    >,
8064            {
8065                ::fidl_next::TwoWayFuture::from_untyped(
8066                    self.client.send_two_way(5592951026866236882, request),
8067                )
8068            }
8069
8070            #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
8071            pub fn dictionary_remove(
8072                &self,
8073
8074                id: impl ::fidl_next::Encode<
8075                    <___T as ::fidl_next::Transport>::SendBuffer,
8076                    Encoded = ::fidl_next::WireU64,
8077                >,
8078
8079                key: impl ::fidl_next::Encode<
8080                    <___T as ::fidl_next::Transport>::SendBuffer,
8081                    Encoded = ::fidl_next::WireString<'static>,
8082                >,
8083
8084                dest_id: impl ::fidl_next::Encode<
8085                    <___T as ::fidl_next::Transport>::SendBuffer,
8086                    Encoded = ::fidl_next::WireBox<'static, crate::WireWrappedCapabilityId>,
8087                >,
8088            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8089            where
8090                <___T as ::fidl_next::Transport>::SendBuffer:
8091                    ::fidl_next::encoder::InternalHandleEncoder,
8092                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8093            {
8094                self.dictionary_remove_with(DictionaryRemove { id, key, dest_id })
8095            }
8096
8097            #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
8098            pub fn dictionary_remove_with<___R>(
8099                &self,
8100                request: ___R,
8101            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
8102            where
8103                ___R: ::fidl_next::Encode<
8104                        <___T as ::fidl_next::Transport>::SendBuffer,
8105                        Encoded = crate::WireCapabilityStoreDictionaryRemoveRequest<'static>,
8106                    >,
8107            {
8108                ::fidl_next::TwoWayFuture::from_untyped(
8109                    self.client.send_two_way(343892214579320051, request),
8110                )
8111            }
8112
8113            #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
8114            pub fn dictionary_copy(
8115                &self,
8116
8117                id: impl ::fidl_next::Encode<
8118                    <___T as ::fidl_next::Transport>::SendBuffer,
8119                    Encoded = ::fidl_next::WireU64,
8120                >,
8121
8122                dest_id: impl ::fidl_next::Encode<
8123                    <___T as ::fidl_next::Transport>::SendBuffer,
8124                    Encoded = ::fidl_next::WireU64,
8125                >,
8126            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
8127            where
8128                <___T as ::fidl_next::Transport>::SendBuffer:
8129                    ::fidl_next::encoder::InternalHandleEncoder,
8130            {
8131                self.dictionary_copy_with(DictionaryCopy { id, dest_id })
8132            }
8133
8134            #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
8135            pub fn dictionary_copy_with<___R>(
8136                &self,
8137                request: ___R,
8138            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
8139            where
8140                ___R: ::fidl_next::Encode<
8141                        <___T as ::fidl_next::Transport>::SendBuffer,
8142                        Encoded = crate::WireCapabilityStoreDictionaryCopyRequest,
8143                    >,
8144            {
8145                ::fidl_next::TwoWayFuture::from_untyped(
8146                    self.client.send_two_way(3977783339739362383, request),
8147                )
8148            }
8149
8150            #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8151            pub fn dictionary_keys(
8152                &self,
8153
8154                id: impl ::fidl_next::Encode<
8155                    <___T as ::fidl_next::Transport>::SendBuffer,
8156                    Encoded = ::fidl_next::WireU64,
8157                >,
8158
8159                iterator: impl ::fidl_next::Encode<
8160                    <___T as ::fidl_next::Transport>::SendBuffer,
8161                    Encoded = ::fidl_next::ServerEnd<
8162                        crate::DictionaryKeysIterator,
8163                        ::fidl_next::fuchsia::WireChannel,
8164                    >,
8165                >,
8166            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
8167            where
8168                <___T as ::fidl_next::Transport>::SendBuffer:
8169                    ::fidl_next::encoder::InternalHandleEncoder,
8170                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8171            {
8172                self.dictionary_keys_with(DictionaryKeys { id, iterator })
8173            }
8174
8175            #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8176            pub fn dictionary_keys_with<___R>(
8177                &self,
8178                request: ___R,
8179            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
8180            where
8181                ___R: ::fidl_next::Encode<
8182                        <___T as ::fidl_next::Transport>::SendBuffer,
8183                        Encoded = crate::WireCapabilityStoreDictionaryKeysRequest,
8184                    >,
8185            {
8186                ::fidl_next::TwoWayFuture::from_untyped(
8187                    self.client.send_two_way(597577248872787102, request),
8188                )
8189            }
8190
8191            #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8192            pub fn dictionary_enumerate(
8193                &self,
8194
8195                id: impl ::fidl_next::Encode<
8196                    <___T as ::fidl_next::Transport>::SendBuffer,
8197                    Encoded = ::fidl_next::WireU64,
8198                >,
8199
8200                iterator: impl ::fidl_next::Encode<
8201                    <___T as ::fidl_next::Transport>::SendBuffer,
8202                    Encoded = ::fidl_next::ServerEnd<
8203                        crate::DictionaryEnumerateIterator,
8204                        ::fidl_next::fuchsia::WireChannel,
8205                    >,
8206                >,
8207            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
8208            where
8209                <___T as ::fidl_next::Transport>::SendBuffer:
8210                    ::fidl_next::encoder::InternalHandleEncoder,
8211                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8212            {
8213                self.dictionary_enumerate_with(DictionaryEnumerate { id, iterator })
8214            }
8215
8216            #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8217            pub fn dictionary_enumerate_with<___R>(
8218                &self,
8219                request: ___R,
8220            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
8221            where
8222                ___R: ::fidl_next::Encode<
8223                        <___T as ::fidl_next::Transport>::SendBuffer,
8224                        Encoded = crate::WireCapabilityStoreDictionaryEnumerateRequest,
8225                    >,
8226            {
8227                ::fidl_next::TwoWayFuture::from_untyped(
8228                    self.client.send_two_way(964467096271472193, request),
8229                )
8230            }
8231
8232            #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8233            pub fn dictionary_drain(
8234                &self,
8235
8236                id: impl ::fidl_next::Encode<
8237                    <___T as ::fidl_next::Transport>::SendBuffer,
8238                    Encoded = ::fidl_next::WireU64,
8239                >,
8240
8241                iterator: impl ::fidl_next::Encode<
8242                    <___T as ::fidl_next::Transport>::SendBuffer,
8243                    Encoded = ::fidl_next::ServerEnd<
8244                        crate::DictionaryDrainIterator,
8245                        ::fidl_next::fuchsia::WireOptionalChannel,
8246                    >,
8247                >,
8248            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
8249            where
8250                <___T as ::fidl_next::Transport>::SendBuffer:
8251                    ::fidl_next::encoder::InternalHandleEncoder,
8252                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8253            {
8254                self.dictionary_drain_with(DictionaryDrain { id, iterator })
8255            }
8256
8257            #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8258            pub fn dictionary_drain_with<___R>(
8259                &self,
8260                request: ___R,
8261            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
8262            where
8263                ___R: ::fidl_next::Encode<
8264                        <___T as ::fidl_next::Transport>::SendBuffer,
8265                        Encoded = crate::WireCapabilityStoreDictionaryDrainRequest,
8266                    >,
8267            {
8268                ::fidl_next::TwoWayFuture::from_untyped(
8269                    self.client.send_two_way(2928364469569621208, request),
8270                )
8271            }
8272        }
8273
8274        /// The server for the `CapabilityStore` protocol.
8275        #[repr(transparent)]
8276        pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
8277            server: ::fidl_next::protocol::Server<___T>,
8278        }
8279
8280        impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
8281    }
8282}
8283
8284/// A client handler for the CapabilityStore protocol.
8285///
8286/// See [`CapabilityStore`] for more details.
8287pub trait CapabilityStoreClientHandler<
8288    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
8289    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8290>
8291{
8292    fn on_unknown_interaction(
8293        &mut self,
8294        ordinal: u64,
8295    ) -> impl ::core::future::Future<
8296        Output = ::core::result::Result<
8297            (),
8298            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8299        >,
8300    > + ::core::marker::Send {
8301        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
8302    }
8303}
8304
8305impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
8306where
8307    ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
8308    ___T: ::fidl_next::Transport,
8309    <capability_store::Duplicate as ::fidl_next::Method>::Response:
8310        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8311    <capability_store::Drop as ::fidl_next::Method>::Response:
8312        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8313    <capability_store::Export as ::fidl_next::Method>::Response:
8314        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8315    <capability_store::Import as ::fidl_next::Method>::Response:
8316        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8317    <capability_store::ConnectorCreate as ::fidl_next::Method>::Response:
8318        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8319    <capability_store::ConnectorOpen as ::fidl_next::Method>::Response:
8320        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8321    <capability_store::DirConnectorCreate as ::fidl_next::Method>::Response:
8322        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8323    <capability_store::DirConnectorOpen as ::fidl_next::Method>::Response:
8324        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8325    <capability_store::DictionaryCreate as ::fidl_next::Method>::Response:
8326        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8327    <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Response:
8328        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8329    <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Response:
8330        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8331    <capability_store::DictionaryInsert as ::fidl_next::Method>::Response:
8332        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8333    <capability_store::DictionaryGet as ::fidl_next::Method>::Response:
8334        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8335    <capability_store::DictionaryRemove as ::fidl_next::Method>::Response:
8336        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8337    <capability_store::DictionaryCopy as ::fidl_next::Method>::Response:
8338        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8339    <capability_store::DictionaryKeys as ::fidl_next::Method>::Response:
8340        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8341    <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Response:
8342        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8343    <capability_store::DictionaryDrain as ::fidl_next::Method>::Response:
8344        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8345{
8346    async fn on_event(
8347        handler: &mut ___H,
8348        ordinal: u64,
8349        buffer: ___T::RecvBuffer,
8350    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8351        match ordinal {
8352            ordinal => handler.on_unknown_interaction(ordinal).await,
8353        }
8354    }
8355}
8356
8357/// A server handler for the CapabilityStore protocol.
8358///
8359/// See [`CapabilityStore`] for more details.
8360pub trait CapabilityStoreServerHandler<
8361    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
8362    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8363>
8364{
8365    #[doc = " Duplicates the capability with `id` to `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `NOT_DUPLICATABLE` if `id` could not be duplicated.\n"]
8366    fn duplicate(
8367        &mut self,
8368
8369        request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
8370
8371        responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
8372    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8373
8374    #[doc = " Drops the capability with `id` from this [`CapabilityStore`].\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
8375    fn drop(
8376        &mut self,
8377
8378        request: ::fidl_next::Request<capability_store::Drop, ___T>,
8379
8380        responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
8381    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8382
8383    #[doc = " Exports the capability with the client-assigned identifier `id` to\n `capability`. This operation removes the capability from the store. If\n this is not desired, [Duplicate] the capability first.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
8384    fn export(
8385        &mut self,
8386
8387        request: ::fidl_next::Request<capability_store::Export, ___T>,
8388
8389        responder: ::fidl_next::Responder<capability_store::Export, ___T>,
8390    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8391
8392    #[doc = " Imports `capability` into this store with the client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `capability` was not a valid [Capability].\n"]
8393    fn import(
8394        &mut self,
8395
8396        request: ::fidl_next::Request<capability_store::Import, ___T>,
8397
8398        responder: ::fidl_next::Responder<capability_store::Import, ___T>,
8399    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8400
8401    #[doc = " Creates a [Connector] from a [Receiver]. Incoming connections to the [Connector] will be\n dispatched to this [Receiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
8402    fn connector_create(
8403        &mut self,
8404
8405        request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
8406
8407        responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
8408    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8409
8410    #[doc = " Open a connection from the provided [Connector] capability that will be dispatched to\n the [Receiver] on the other end.\n\n If there is an error, it will be reported as a zx.Status epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
8411    fn connector_open(
8412        &mut self,
8413
8414        request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
8415
8416        responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
8417    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8418
8419    #[doc = " Creates a [DirConnector] from a [DirReceiver]. Incoming connections to the [DirConnector]\n will be dispatched to this [DirReceiver].\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
8420    fn dir_connector_create(
8421        &mut self,
8422
8423        request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
8424
8425        responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
8426    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8427
8428    #[doc = " Open a connection from the provided [DirConnector] capability that will be dispatched to\n the [DirReceiver] on the other end.\n\n This method does not take `Open`/`Open3` parameters such as `flags` or `path`.\n Clients that wish to specify these can get an initial connection from this method\n and call `fuchsia.io/Directory.Open` on it. See the [DirReceiver] documentation for\n more information about the expectations of the server side.\n\n If there was an error making the connection, it will be reported as a zx.Status\n epitaph on `server_end`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a connector capability.\n"]
8429    fn dir_connector_open(
8430        &mut self,
8431
8432        request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
8433
8434        responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
8435    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8436
8437    #[doc = " Creates a new empty dictionary in this [`CapabilityStore`] with client-assigned `id`.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n"]
8438    fn dictionary_create(
8439        &mut self,
8440
8441        request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
8442
8443        responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
8444    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8445
8446    #[doc = " Imports a dictionary in the form of a channel.\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if a capability with `id` already exists in this store.\n - `BAD_CAPABILITY` if `client_end` was not a valid dictionary channel.\n"]
8447    fn dictionary_legacy_import(
8448        &mut self,
8449
8450        request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
8451
8452        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
8453    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8454
8455    #[doc = " Binds a channel to the dictionary with `id`. The channel can\n be re-imported into a [CapabilityStore] with [DictionaryImportLegacy].\n\n This is a legacy API to support backward compatibility with APIs that take a [Dictionary]\n channel.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n"]
8456    fn dictionary_legacy_export(
8457        &mut self,
8458
8459        request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
8460
8461        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
8462    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8463
8464    #[doc = " Inserts `item` into the dictionary with `id`. `item.value` is moved into the dictionary and\n its id is released if this call succeeds.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_ALREADY_EXISTS` if the dictionary already contains an item with `item.key`.\n"]
8465    fn dictionary_insert(
8466        &mut self,
8467
8468        request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
8469
8470        responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
8471    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8472
8473    #[doc = " Get a duplicate of a capability from the dictionary with `id`, which is\n loaded into `dest_id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a recognized capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `item.key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain `key`.\n - `NOT_DUPLICATABLE` if the capability could not be duplicated.\n"]
8474    fn dictionary_get(
8475        &mut self,
8476
8477        request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
8478
8479        responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
8480    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8481
8482    #[doc = " Removes a key from the dictionary with `id`. If `dest_id` is present, loads the value\n into it, otherwise discards the value.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `INVALID_KEY` if `key` was invalid.\n - `ITEM_NOT_FOUND` if the dictionary does not contain the key.\n"]
8483    fn dictionary_remove(
8484        &mut self,
8485
8486        request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
8487
8488        responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
8489    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8490
8491    #[doc = " Create a new dictionary that contains a duplicate of all the entries in\n the dictionary with `id`, assigning `dest_id` to the new dictionary.\n The runtime of this method is linear in the number of top-level entries\n in the dictionary.\n\n For example, if the dictionary contains nested dictionaries, the newly\n created dictionary will contain references to those same nested\n dictionaries because the entries are duplicated rather than deep-copied.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `ID_ALREADY_EXISTS` if a capability with `dest_id` already exists in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n - `NOT_DUPLICATABLE` if one of the capabilities in `id` could not be duplicated.\n"]
8492    fn dictionary_copy(
8493        &mut self,
8494
8495        request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
8496
8497        responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
8498    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8499
8500    #[doc = " Enumerates the keys in the dictionary with `id`.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8501    fn dictionary_keys(
8502        &mut self,
8503
8504        request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
8505
8506        responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
8507    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8508
8509    #[doc = " Enumerates the items (keys and values) in the dictionary with `id`.\n\n Creates a duplicate of each value (capability). If a value could not be duplicated,\n the value will be null.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8510    fn dictionary_enumerate(
8511        &mut self,
8512
8513        request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
8514
8515        responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
8516    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8517
8518    #[doc = " Removes all the entries in this dictionary, returning them in `contents` if provided.\n If `contents` is not provided, all the items are discarded without enumerating them.\n\n Errors:\n\n - `ID_NOT_FOUND` if `id` was not a valid capability id in this store.\n - `WRONG_TYPE` if `id` was not a dictionary.\n"]
8519    fn dictionary_drain(
8520        &mut self,
8521
8522        request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
8523
8524        responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
8525    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8526
8527    fn on_unknown_interaction(
8528        &mut self,
8529        ordinal: u64,
8530    ) -> impl ::core::future::Future<
8531        Output = ::core::result::Result<
8532            (),
8533            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8534        >,
8535    > + ::core::marker::Send {
8536        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
8537    }
8538}
8539
8540impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
8541where
8542    ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
8543    ___T: ::fidl_next::Transport,
8544    <capability_store::Duplicate as ::fidl_next::Method>::Request:
8545        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8546    <capability_store::Drop as ::fidl_next::Method>::Request:
8547        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8548    <capability_store::Export as ::fidl_next::Method>::Request:
8549        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8550    <capability_store::Import as ::fidl_next::Method>::Request:
8551        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8552    <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
8553        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8554    <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
8555        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8556    <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
8557        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8558    <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
8559        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8560    <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
8561        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8562    <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
8563        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8564    <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
8565        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8566    <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
8567        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8568    <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
8569        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8570    <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
8571        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8572    <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
8573        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8574    <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
8575        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8576    <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
8577        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8578    <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
8579        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
8580{
8581    async fn on_one_way(
8582        handler: &mut ___H,
8583        ordinal: u64,
8584        buffer: ___T::RecvBuffer,
8585    ) -> ::core::result::Result<
8586        (),
8587        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8588    > {
8589        match ordinal {
8590            ordinal => handler.on_unknown_interaction(ordinal).await,
8591        }
8592    }
8593
8594    async fn on_two_way(
8595        handler: &mut ___H,
8596        ordinal: u64,
8597        buffer: ___T::RecvBuffer,
8598        responder: ::fidl_next::protocol::Responder<___T>,
8599    ) -> ::core::result::Result<
8600        (),
8601        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8602    > {
8603        match ordinal {
8604            6727592627741008260 => {
8605                let responder = ::fidl_next::Responder::from_untyped(responder);
8606
8607                match ::fidl_next::DecoderExt::decode(buffer) {
8608                    Ok(decoded) => {
8609                        handler.duplicate(decoded, responder).await;
8610                        Ok(())
8611                    }
8612                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8613                        ordinal: 6727592627741008260,
8614                        error,
8615                    }),
8616                }
8617            }
8618
8619            753328233834620249 => {
8620                let responder = ::fidl_next::Responder::from_untyped(responder);
8621
8622                match ::fidl_next::DecoderExt::decode(buffer) {
8623                    Ok(decoded) => {
8624                        handler.drop(decoded, responder).await;
8625                        Ok(())
8626                    }
8627                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8628                        ordinal: 753328233834620249,
8629                        error,
8630                    }),
8631                }
8632            }
8633
8634            226159162093533951 => {
8635                let responder = ::fidl_next::Responder::from_untyped(responder);
8636
8637                match ::fidl_next::DecoderExt::decode(buffer) {
8638                    Ok(decoded) => {
8639                        handler.export(decoded, responder).await;
8640                        Ok(())
8641                    }
8642                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8643                        ordinal: 226159162093533951,
8644                        error,
8645                    }),
8646                }
8647            }
8648
8649            2276030276116435867 => {
8650                let responder = ::fidl_next::Responder::from_untyped(responder);
8651
8652                match ::fidl_next::DecoderExt::decode(buffer) {
8653                    Ok(decoded) => {
8654                        handler.import(decoded, responder).await;
8655                        Ok(())
8656                    }
8657                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8658                        ordinal: 2276030276116435867,
8659                        error,
8660                    }),
8661                }
8662            }
8663
8664            2979461408102095909 => {
8665                let responder = ::fidl_next::Responder::from_untyped(responder);
8666
8667                match ::fidl_next::DecoderExt::decode(buffer) {
8668                    Ok(decoded) => {
8669                        handler.connector_create(decoded, responder).await;
8670                        Ok(())
8671                    }
8672                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8673                        ordinal: 2979461408102095909,
8674                        error,
8675                    }),
8676                }
8677            }
8678
8679            6016362336453278623 => {
8680                let responder = ::fidl_next::Responder::from_untyped(responder);
8681
8682                match ::fidl_next::DecoderExt::decode(buffer) {
8683                    Ok(decoded) => {
8684                        handler.connector_open(decoded, responder).await;
8685                        Ok(())
8686                    }
8687                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8688                        ordinal: 6016362336453278623,
8689                        error,
8690                    }),
8691                }
8692            }
8693
8694            1756747594275428795 => {
8695                let responder = ::fidl_next::Responder::from_untyped(responder);
8696
8697                match ::fidl_next::DecoderExt::decode(buffer) {
8698                    Ok(decoded) => {
8699                        handler.dir_connector_create(decoded, responder).await;
8700                        Ok(())
8701                    }
8702                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8703                        ordinal: 1756747594275428795,
8704                        error,
8705                    }),
8706                }
8707            }
8708
8709            6219704004220369153 => {
8710                let responder = ::fidl_next::Responder::from_untyped(responder);
8711
8712                match ::fidl_next::DecoderExt::decode(buffer) {
8713                    Ok(decoded) => {
8714                        handler.dir_connector_open(decoded, responder).await;
8715                        Ok(())
8716                    }
8717                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8718                        ordinal: 6219704004220369153,
8719                        error,
8720                    }),
8721                }
8722            }
8723
8724            7608770958894948499 => {
8725                let responder = ::fidl_next::Responder::from_untyped(responder);
8726
8727                match ::fidl_next::DecoderExt::decode(buffer) {
8728                    Ok(decoded) => {
8729                        handler.dictionary_create(decoded, responder).await;
8730                        Ok(())
8731                    }
8732                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8733                        ordinal: 7608770958894948499,
8734                        error,
8735                    }),
8736                }
8737            }
8738
8739            8285893703432012383 => {
8740                let responder = ::fidl_next::Responder::from_untyped(responder);
8741
8742                match ::fidl_next::DecoderExt::decode(buffer) {
8743                    Ok(decoded) => {
8744                        handler.dictionary_legacy_import(decoded, responder).await;
8745                        Ok(())
8746                    }
8747                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8748                        ordinal: 8285893703432012383,
8749                        error,
8750                    }),
8751                }
8752            }
8753
8754            4647175832683306445 => {
8755                let responder = ::fidl_next::Responder::from_untyped(responder);
8756
8757                match ::fidl_next::DecoderExt::decode(buffer) {
8758                    Ok(decoded) => {
8759                        handler.dictionary_legacy_export(decoded, responder).await;
8760                        Ok(())
8761                    }
8762                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8763                        ordinal: 4647175832683306445,
8764                        error,
8765                    }),
8766                }
8767            }
8768
8769            8575443262986538023 => {
8770                let responder = ::fidl_next::Responder::from_untyped(responder);
8771
8772                match ::fidl_next::DecoderExt::decode(buffer) {
8773                    Ok(decoded) => {
8774                        handler.dictionary_insert(decoded, responder).await;
8775                        Ok(())
8776                    }
8777                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8778                        ordinal: 8575443262986538023,
8779                        error,
8780                    }),
8781                }
8782            }
8783
8784            5592951026866236882 => {
8785                let responder = ::fidl_next::Responder::from_untyped(responder);
8786
8787                match ::fidl_next::DecoderExt::decode(buffer) {
8788                    Ok(decoded) => {
8789                        handler.dictionary_get(decoded, responder).await;
8790                        Ok(())
8791                    }
8792                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8793                        ordinal: 5592951026866236882,
8794                        error,
8795                    }),
8796                }
8797            }
8798
8799            343892214579320051 => {
8800                let responder = ::fidl_next::Responder::from_untyped(responder);
8801
8802                match ::fidl_next::DecoderExt::decode(buffer) {
8803                    Ok(decoded) => {
8804                        handler.dictionary_remove(decoded, responder).await;
8805                        Ok(())
8806                    }
8807                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8808                        ordinal: 343892214579320051,
8809                        error,
8810                    }),
8811                }
8812            }
8813
8814            3977783339739362383 => {
8815                let responder = ::fidl_next::Responder::from_untyped(responder);
8816
8817                match ::fidl_next::DecoderExt::decode(buffer) {
8818                    Ok(decoded) => {
8819                        handler.dictionary_copy(decoded, responder).await;
8820                        Ok(())
8821                    }
8822                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8823                        ordinal: 3977783339739362383,
8824                        error,
8825                    }),
8826                }
8827            }
8828
8829            597577248872787102 => {
8830                let responder = ::fidl_next::Responder::from_untyped(responder);
8831
8832                match ::fidl_next::DecoderExt::decode(buffer) {
8833                    Ok(decoded) => {
8834                        handler.dictionary_keys(decoded, responder).await;
8835                        Ok(())
8836                    }
8837                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8838                        ordinal: 597577248872787102,
8839                        error,
8840                    }),
8841                }
8842            }
8843
8844            964467096271472193 => {
8845                let responder = ::fidl_next::Responder::from_untyped(responder);
8846
8847                match ::fidl_next::DecoderExt::decode(buffer) {
8848                    Ok(decoded) => {
8849                        handler.dictionary_enumerate(decoded, responder).await;
8850                        Ok(())
8851                    }
8852                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8853                        ordinal: 964467096271472193,
8854                        error,
8855                    }),
8856                }
8857            }
8858
8859            2928364469569621208 => {
8860                let responder = ::fidl_next::Responder::from_untyped(responder);
8861
8862                match ::fidl_next::DecoderExt::decode(buffer) {
8863                    Ok(decoded) => {
8864                        handler.dictionary_drain(decoded, responder).await;
8865                        Ok(())
8866                    }
8867                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8868                        ordinal: 2928364469569621208,
8869                        error,
8870                    }),
8871                }
8872            }
8873
8874            ordinal => handler.on_unknown_interaction(ordinal).await,
8875        }
8876    }
8877}
8878
8879#[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
8880#[derive(PartialEq, Debug)]
8881#[repr(C)]
8882pub struct InstanceToken {
8883    pub token: ::fidl_next::fuchsia::zx::EventPair,
8884}
8885
8886impl ::fidl_next::Encodable for InstanceToken {
8887    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireInstanceToken> = unsafe {
8888        ::fidl_next::CopyOptimization::enable_if(
8889            true
8890
8891                && <
8892                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
8893                >::COPY_OPTIMIZATION.is_enabled()
8894
8895        )
8896    };
8897
8898    type Encoded = WireInstanceToken;
8899}
8900
8901unsafe impl<___E> ::fidl_next::Encode<___E> for InstanceToken
8902where
8903    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8904    ___E: ::fidl_next::fuchsia::HandleEncoder,
8905{
8906    #[inline]
8907    fn encode(
8908        self,
8909        encoder_: &mut ___E,
8910        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
8911    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8912        ::fidl_next::munge! {
8913            let Self::Encoded {
8914                token,
8915
8916            } = out_;
8917        }
8918
8919        ::fidl_next::Encode::encode(self.token, encoder_, token)?;
8920
8921        Ok(())
8922    }
8923}
8924
8925impl ::fidl_next::EncodableOption for InstanceToken {
8926    type EncodedOption = ::fidl_next::WireBox<'static, WireInstanceToken>;
8927}
8928
8929unsafe impl<___E> ::fidl_next::EncodeOption<___E> for InstanceToken
8930where
8931    ___E: ::fidl_next::Encoder + ?Sized,
8932    InstanceToken: ::fidl_next::Encode<___E>,
8933{
8934    #[inline]
8935    fn encode_option(
8936        this: ::core::option::Option<Self>,
8937        encoder: &mut ___E,
8938        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
8939    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8940        if let Some(inner) = this {
8941            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8942            ::fidl_next::WireBox::encode_present(out);
8943        } else {
8944            ::fidl_next::WireBox::encode_absent(out);
8945        }
8946
8947        Ok(())
8948    }
8949}
8950
8951impl ::fidl_next::FromWire<WireInstanceToken> for InstanceToken {
8952    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireInstanceToken, Self> = unsafe {
8953        ::fidl_next::CopyOptimization::enable_if(
8954            true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
8955                ::fidl_next::fuchsia::WireEventPair,
8956            >>::COPY_OPTIMIZATION
8957                .is_enabled(),
8958        )
8959    };
8960
8961    #[inline]
8962    fn from_wire(wire: WireInstanceToken) -> Self {
8963        Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
8964    }
8965}
8966
8967impl ::fidl_next::IntoNatural for WireInstanceToken {
8968    type Natural = InstanceToken;
8969}
8970
8971/// The wire type corresponding to [`InstanceToken`].
8972#[derive(Debug)]
8973#[repr(C)]
8974pub struct WireInstanceToken {
8975    pub token: ::fidl_next::fuchsia::WireEventPair,
8976}
8977static_assertions::const_assert_eq!(std::mem::size_of::<WireInstanceToken>(), 4);
8978static_assertions::const_assert_eq!(std::mem::align_of::<WireInstanceToken>(), 4);
8979
8980static_assertions::const_assert_eq!(std::mem::offset_of!(WireInstanceToken, token), 0);
8981
8982unsafe impl ::fidl_next::Wire for WireInstanceToken {
8983    type Decoded<'de> = WireInstanceToken;
8984
8985    #[inline]
8986    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8987        ::fidl_next::munge! {
8988            let Self {
8989
8990                token,
8991
8992            } = &mut *out_;
8993        }
8994
8995        ::fidl_next::Wire::zero_padding(token);
8996    }
8997}
8998
8999unsafe impl<___D> ::fidl_next::Decode<___D> for WireInstanceToken
9000where
9001    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9002    ___D: ::fidl_next::fuchsia::HandleDecoder,
9003{
9004    fn decode(
9005        slot_: ::fidl_next::Slot<'_, Self>,
9006        decoder_: &mut ___D,
9007    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9008        ::fidl_next::munge! {
9009            let Self {
9010
9011                mut token,
9012
9013            } = slot_;
9014        }
9015
9016        ::fidl_next::Decode::decode(token.as_mut(), decoder_)?;
9017
9018        Ok(())
9019    }
9020}
9021
9022#[doc = " A request for a route.\n"]
9023#[derive(PartialEq, Debug, Default)]
9024pub struct RouteRequest {
9025    pub requesting: ::core::option::Option<crate::InstanceToken>,
9026
9027    pub metadata: ::core::option::Option<crate::DictionaryRef>,
9028}
9029
9030impl RouteRequest {
9031    fn __max_ordinal(&self) -> usize {
9032        if self.metadata.is_some() {
9033            return 2;
9034        }
9035
9036        if self.requesting.is_some() {
9037            return 1;
9038        }
9039
9040        0
9041    }
9042}
9043
9044impl ::fidl_next::Encodable for RouteRequest {
9045    type Encoded = WireRouteRequest<'static>;
9046}
9047
9048unsafe impl<___E> ::fidl_next::Encode<___E> for RouteRequest
9049where
9050    ___E: ::fidl_next::Encoder + ?Sized,
9051    ___E: ::fidl_next::fuchsia::HandleEncoder,
9052{
9053    #[inline]
9054    fn encode(
9055        mut self,
9056        encoder: &mut ___E,
9057        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9058    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9059        ::fidl_next::munge!(let WireRouteRequest { table } = out);
9060
9061        let max_ord = self.__max_ordinal();
9062
9063        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
9064        ::fidl_next::Wire::zero_padding(&mut out);
9065
9066        let mut preallocated =
9067            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
9068
9069        for i in 1..=max_ord {
9070            match i {
9071                2 => {
9072                    if let Some(value) = self.metadata.take() {
9073                        ::fidl_next::WireEnvelope::encode_value(
9074                            value,
9075                            preallocated.encoder,
9076                            &mut out,
9077                        )?;
9078                    } else {
9079                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
9080                    }
9081                }
9082
9083                1 => {
9084                    if let Some(value) = self.requesting.take() {
9085                        ::fidl_next::WireEnvelope::encode_value(
9086                            value,
9087                            preallocated.encoder,
9088                            &mut out,
9089                        )?;
9090                    } else {
9091                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
9092                    }
9093                }
9094
9095                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
9096            }
9097            unsafe {
9098                preallocated.write_next(out.assume_init_ref());
9099            }
9100        }
9101
9102        ::fidl_next::WireTable::encode_len(table, max_ord);
9103
9104        Ok(())
9105    }
9106}
9107
9108impl<'de> ::fidl_next::FromWire<WireRouteRequest<'de>> for RouteRequest {
9109    #[inline]
9110    fn from_wire(wire_: WireRouteRequest<'de>) -> Self {
9111        let wire_ = ::core::mem::ManuallyDrop::new(wire_);
9112
9113        let requesting = wire_.table.get(1);
9114
9115        let metadata = wire_.table.get(2);
9116
9117        Self {
9118            requesting: requesting.map(|envelope| {
9119                ::fidl_next::FromWire::from_wire(unsafe {
9120                    envelope.read_unchecked::<crate::WireInstanceToken>()
9121                })
9122            }),
9123
9124            metadata: metadata.map(|envelope| {
9125                ::fidl_next::FromWire::from_wire(unsafe {
9126                    envelope.read_unchecked::<crate::WireDictionaryRef>()
9127                })
9128            }),
9129        }
9130    }
9131}
9132
9133impl<'de> ::fidl_next::IntoNatural for WireRouteRequest<'de> {
9134    type Natural = RouteRequest;
9135}
9136
9137/// The wire type corresponding to [`RouteRequest`].
9138#[repr(C)]
9139pub struct WireRouteRequest<'de> {
9140    table: ::fidl_next::WireTable<'de>,
9141}
9142
9143impl<'de> Drop for WireRouteRequest<'de> {
9144    fn drop(&mut self) {
9145        let _ = self
9146            .table
9147            .get(1)
9148            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireInstanceToken>() });
9149
9150        let _ = self
9151            .table
9152            .get(2)
9153            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireDictionaryRef>() });
9154    }
9155}
9156
9157unsafe impl ::fidl_next::Wire for WireRouteRequest<'static> {
9158    type Decoded<'de> = WireRouteRequest<'de>;
9159
9160    #[inline]
9161    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9162        ::fidl_next::munge!(let Self { table } = out);
9163        ::fidl_next::WireTable::zero_padding(table);
9164    }
9165}
9166
9167unsafe impl<___D> ::fidl_next::Decode<___D> for WireRouteRequest<'static>
9168where
9169    ___D: ::fidl_next::Decoder + ?Sized,
9170    ___D: ::fidl_next::fuchsia::HandleDecoder,
9171{
9172    fn decode(
9173        slot: ::fidl_next::Slot<'_, Self>,
9174        decoder: &mut ___D,
9175    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9176        ::fidl_next::munge!(let Self { table } = slot);
9177
9178        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
9179            match ordinal {
9180                0 => unsafe { ::core::hint::unreachable_unchecked() },
9181
9182                1 => {
9183                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireInstanceToken>(
9184                        slot.as_mut(),
9185                        decoder,
9186                    )?;
9187
9188                    Ok(())
9189                }
9190
9191                2 => {
9192                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireDictionaryRef>(
9193                        slot.as_mut(),
9194                        decoder,
9195                    )?;
9196
9197                    Ok(())
9198                }
9199
9200                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
9201            }
9202        })
9203    }
9204}
9205
9206impl<'de> WireRouteRequest<'de> {
9207    pub fn requesting(&self) -> ::core::option::Option<&crate::WireInstanceToken> {
9208        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
9209    }
9210
9211    pub fn metadata(&self) -> ::core::option::Option<&crate::WireDictionaryRef> {
9212        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
9213    }
9214}
9215
9216impl<'de> ::core::fmt::Debug for WireRouteRequest<'de> {
9217    fn fmt(
9218        &self,
9219        f: &mut ::core::fmt::Formatter<'_>,
9220    ) -> ::core::result::Result<(), ::core::fmt::Error> {
9221        f.debug_struct("RouteRequest")
9222            .field("requesting", &self.requesting())
9223            .field("metadata", &self.metadata())
9224            .finish()
9225    }
9226}
9227
9228#[derive(PartialEq, Debug)]
9229pub enum ConnectorRouterRouteResponse {
9230    Connector(crate::Connector),
9231
9232    Unavailable(crate::Unit),
9233}
9234
9235impl ::fidl_next::Encodable for ConnectorRouterRouteResponse {
9236    type Encoded = WireConnectorRouterRouteResponse;
9237}
9238
9239unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectorRouterRouteResponse
9240where
9241    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9242    ___E: ::fidl_next::fuchsia::HandleEncoder,
9243{
9244    #[inline]
9245    fn encode(
9246        self,
9247        encoder: &mut ___E,
9248        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9249    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9250        ::fidl_next::munge!(let WireConnectorRouterRouteResponse { raw, _phantom: _ } = out);
9251
9252        match self {
9253            Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
9254                ___E,
9255                crate::Connector,
9256            >(value, 1, encoder, raw)?,
9257
9258            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
9259                ___E,
9260                crate::Unit,
9261            >(value, 2, encoder, raw)?,
9262        }
9263
9264        Ok(())
9265    }
9266}
9267
9268impl ::fidl_next::EncodableOption for ConnectorRouterRouteResponse {
9269    type EncodedOption = WireOptionalConnectorRouterRouteResponse;
9270}
9271
9272unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConnectorRouterRouteResponse
9273where
9274    ___E: ?Sized,
9275    ConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
9276{
9277    #[inline]
9278    fn encode_option(
9279        this: ::core::option::Option<Self>,
9280        encoder: &mut ___E,
9281        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
9282    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9283        ::fidl_next::munge!(let WireOptionalConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
9284
9285        if let Some(inner) = this {
9286            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
9287            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
9288        } else {
9289            ::fidl_next::RawWireUnion::encode_absent(raw);
9290        }
9291
9292        Ok(())
9293    }
9294}
9295
9296impl ::fidl_next::FromWire<WireConnectorRouterRouteResponse> for ConnectorRouterRouteResponse {
9297    #[inline]
9298    fn from_wire(wire: WireConnectorRouterRouteResponse) -> Self {
9299        let wire = ::core::mem::ManuallyDrop::new(wire);
9300        match wire.raw.ordinal() {
9301            1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
9302                wire.raw.get().read_unchecked::<crate::WireConnector>()
9303            })),
9304
9305            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
9306                wire.raw.get().read_unchecked::<crate::WireUnit>()
9307            })),
9308
9309            _ => unsafe { ::core::hint::unreachable_unchecked() },
9310        }
9311    }
9312}
9313
9314impl ::fidl_next::IntoNatural for WireConnectorRouterRouteResponse {
9315    type Natural = ConnectorRouterRouteResponse;
9316}
9317
9318impl ::fidl_next::FromWireOption<WireOptionalConnectorRouterRouteResponse>
9319    for ConnectorRouterRouteResponse
9320{
9321    #[inline]
9322    fn from_wire_option(
9323        wire: WireOptionalConnectorRouterRouteResponse,
9324    ) -> ::core::option::Option<Self> {
9325        if let Some(inner) = wire.into_option() {
9326            Some(::fidl_next::FromWire::from_wire(inner))
9327        } else {
9328            None
9329        }
9330    }
9331}
9332
9333impl ::fidl_next::IntoNatural for WireOptionalConnectorRouterRouteResponse {
9334    type Natural = ::core::option::Option<ConnectorRouterRouteResponse>;
9335}
9336
9337impl ::fidl_next::FromWireOption<WireOptionalConnectorRouterRouteResponse>
9338    for Box<ConnectorRouterRouteResponse>
9339{
9340    #[inline]
9341    fn from_wire_option(
9342        wire: WireOptionalConnectorRouterRouteResponse,
9343    ) -> ::core::option::Option<Self> {
9344        <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
9345            WireOptionalConnectorRouterRouteResponse,
9346        >>::from_wire_option(wire)
9347        .map(Box::new)
9348    }
9349}
9350
9351/// The wire type corresponding to [`ConnectorRouterRouteResponse`].
9352#[repr(transparent)]
9353pub struct WireConnectorRouterRouteResponse {
9354    raw: ::fidl_next::RawWireUnion,
9355    _phantom: ::core::marker::PhantomData<()>,
9356}
9357
9358impl Drop for WireConnectorRouterRouteResponse {
9359    fn drop(&mut self) {
9360        match self.raw.ordinal() {
9361            1 => {
9362                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireConnector>() };
9363            }
9364
9365            2 => {
9366                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
9367            }
9368
9369            _ => unsafe { ::core::hint::unreachable_unchecked() },
9370        }
9371    }
9372}
9373
9374unsafe impl ::fidl_next::Wire for WireConnectorRouterRouteResponse {
9375    type Decoded<'de> = WireConnectorRouterRouteResponse;
9376
9377    #[inline]
9378    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9379        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9380        ::fidl_next::RawWireUnion::zero_padding(raw);
9381    }
9382}
9383
9384pub mod connector_router_route_response {
9385    pub enum Ref<'de> {
9386        Connector(&'de crate::WireConnector),
9387
9388        Unavailable(&'de crate::WireUnit),
9389    }
9390}
9391
9392impl WireConnectorRouterRouteResponse {
9393    pub fn as_ref(&self) -> crate::connector_router_route_response::Ref<'_> {
9394        match self.raw.ordinal() {
9395            1 => crate::connector_router_route_response::Ref::Connector(unsafe {
9396                self.raw.get().deref_unchecked::<crate::WireConnector>()
9397            }),
9398
9399            2 => crate::connector_router_route_response::Ref::Unavailable(unsafe {
9400                self.raw.get().deref_unchecked::<crate::WireUnit>()
9401            }),
9402
9403            _ => unsafe { ::core::hint::unreachable_unchecked() },
9404        }
9405    }
9406}
9407
9408unsafe impl<___D> ::fidl_next::Decode<___D> for WireConnectorRouterRouteResponse
9409where
9410    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9411    ___D: ::fidl_next::fuchsia::HandleDecoder,
9412{
9413    fn decode(
9414        mut slot: ::fidl_next::Slot<'_, Self>,
9415        decoder: &mut ___D,
9416    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9417        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9418        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
9419            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireConnector>(
9420                raw, decoder,
9421            )?,
9422
9423            2 => {
9424                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
9425            }
9426
9427            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
9428        }
9429
9430        Ok(())
9431    }
9432}
9433
9434impl ::core::fmt::Debug for WireConnectorRouterRouteResponse {
9435    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9436        match self.raw.ordinal() {
9437            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireConnector>().fmt(f) },
9438            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
9439            _ => unsafe { ::core::hint::unreachable_unchecked() },
9440        }
9441    }
9442}
9443
9444#[repr(transparent)]
9445pub struct WireOptionalConnectorRouterRouteResponse {
9446    raw: ::fidl_next::RawWireUnion,
9447    _phantom: ::core::marker::PhantomData<()>,
9448}
9449
9450unsafe impl ::fidl_next::Wire for WireOptionalConnectorRouterRouteResponse {
9451    type Decoded<'de> = WireOptionalConnectorRouterRouteResponse;
9452
9453    #[inline]
9454    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
9455        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
9456        ::fidl_next::RawWireUnion::zero_padding(raw);
9457    }
9458}
9459
9460impl WireOptionalConnectorRouterRouteResponse {
9461    pub fn is_some(&self) -> bool {
9462        self.raw.is_some()
9463    }
9464
9465    pub fn is_none(&self) -> bool {
9466        self.raw.is_none()
9467    }
9468
9469    pub fn as_ref(&self) -> ::core::option::Option<&WireConnectorRouterRouteResponse> {
9470        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
9471    }
9472
9473    pub fn into_option(self) -> ::core::option::Option<WireConnectorRouterRouteResponse> {
9474        if self.is_some() {
9475            Some(WireConnectorRouterRouteResponse {
9476                raw: self.raw,
9477                _phantom: ::core::marker::PhantomData,
9478            })
9479        } else {
9480            None
9481        }
9482    }
9483}
9484
9485unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalConnectorRouterRouteResponse
9486where
9487    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9488    ___D: ::fidl_next::fuchsia::HandleDecoder,
9489{
9490    fn decode(
9491        mut slot: ::fidl_next::Slot<'_, Self>,
9492        decoder: &mut ___D,
9493    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9494        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
9495        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
9496            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireConnector>(
9497                raw, decoder,
9498            )?,
9499
9500            2 => {
9501                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
9502            }
9503
9504            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
9505            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
9506        }
9507
9508        Ok(())
9509    }
9510}
9511
9512impl ::core::fmt::Debug for WireOptionalConnectorRouterRouteResponse {
9513    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
9514        self.as_ref().fmt(f)
9515    }
9516}
9517
9518#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9519#[repr(u32)]
9520pub enum RouterError {
9521    NotFound = 1,
9522    InvalidArgs = 2,
9523    NotSupported = 3,
9524    Internal = 4,
9525    UnknownOrdinal_(u32) = 5,
9526}
9527
9528impl ::fidl_next::Encodable for RouterError {
9529    type Encoded = WireRouterError;
9530}
9531impl ::std::convert::From<u32> for RouterError {
9532    fn from(value: u32) -> Self {
9533        match value {
9534            1 => Self::NotFound,
9535            2 => Self::InvalidArgs,
9536            3 => Self::NotSupported,
9537            4 => Self::Internal,
9538
9539            _ => Self::UnknownOrdinal_(value),
9540        }
9541    }
9542}
9543
9544unsafe impl<___E> ::fidl_next::Encode<___E> for RouterError
9545where
9546    ___E: ?Sized,
9547{
9548    #[inline]
9549    fn encode(
9550        self,
9551        encoder: &mut ___E,
9552        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9553    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9554        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
9555    }
9556}
9557
9558unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RouterError
9559where
9560    ___E: ?Sized,
9561{
9562    #[inline]
9563    fn encode_ref(
9564        &self,
9565        encoder: &mut ___E,
9566        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9567    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9568        ::fidl_next::munge!(let WireRouterError { value } = out);
9569        let _ = value.write(::fidl_next::WireU32::from(match *self {
9570            Self::NotFound => 1,
9571
9572            Self::InvalidArgs => 2,
9573
9574            Self::NotSupported => 3,
9575
9576            Self::Internal => 4,
9577
9578            Self::UnknownOrdinal_(value) => value,
9579        }));
9580
9581        Ok(())
9582    }
9583}
9584
9585impl ::core::convert::From<WireRouterError> for RouterError {
9586    fn from(wire: WireRouterError) -> Self {
9587        match u32::from(wire.value) {
9588            1 => Self::NotFound,
9589
9590            2 => Self::InvalidArgs,
9591
9592            3 => Self::NotSupported,
9593
9594            4 => Self::Internal,
9595
9596            value => Self::UnknownOrdinal_(value),
9597        }
9598    }
9599}
9600
9601impl ::fidl_next::FromWire<WireRouterError> for RouterError {
9602    #[inline]
9603    fn from_wire(wire: WireRouterError) -> Self {
9604        Self::from(wire)
9605    }
9606}
9607
9608impl ::fidl_next::IntoNatural for WireRouterError {
9609    type Natural = RouterError;
9610}
9611
9612impl ::fidl_next::FromWireRef<WireRouterError> for RouterError {
9613    #[inline]
9614    fn from_wire_ref(wire: &WireRouterError) -> Self {
9615        Self::from(*wire)
9616    }
9617}
9618
9619/// The wire type corresponding to [`RouterError`].
9620#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9621#[repr(transparent)]
9622pub struct WireRouterError {
9623    value: ::fidl_next::WireU32,
9624}
9625
9626unsafe impl ::fidl_next::Wire for WireRouterError {
9627    type Decoded<'de> = Self;
9628
9629    #[inline]
9630    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9631        // Wire enums have no padding
9632    }
9633}
9634
9635impl WireRouterError {
9636    pub const NOT_FOUND: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(1) };
9637
9638    pub const INVALID_ARGS: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(2) };
9639
9640    pub const NOT_SUPPORTED: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(3) };
9641
9642    pub const INTERNAL: WireRouterError = WireRouterError { value: ::fidl_next::WireU32(4) };
9643}
9644
9645unsafe impl<___D> ::fidl_next::Decode<___D> for WireRouterError
9646where
9647    ___D: ?Sized,
9648{
9649    fn decode(
9650        slot: ::fidl_next::Slot<'_, Self>,
9651        _: &mut ___D,
9652    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9653        Ok(())
9654    }
9655}
9656
9657impl ::core::convert::From<RouterError> for WireRouterError {
9658    fn from(natural: RouterError) -> Self {
9659        match natural {
9660            RouterError::NotFound => WireRouterError::NOT_FOUND,
9661
9662            RouterError::InvalidArgs => WireRouterError::INVALID_ARGS,
9663
9664            RouterError::NotSupported => WireRouterError::NOT_SUPPORTED,
9665
9666            RouterError::Internal => WireRouterError::INTERNAL,
9667
9668            RouterError::UnknownOrdinal_(value) => {
9669                WireRouterError { value: ::fidl_next::WireU32::from(value) }
9670            }
9671        }
9672    }
9673}
9674
9675/// The type corresponding to the ConnectorRouter protocol.
9676#[derive(PartialEq, Debug)]
9677pub struct ConnectorRouter;
9678
9679impl ::fidl_next::Discoverable for ConnectorRouter {
9680    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
9681}
9682
9683pub mod connector_router {
9684    pub mod prelude {
9685        pub use crate::{
9686            ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
9687            connector_router,
9688        };
9689
9690        pub use crate::ConnectorRouterRouteResponse;
9691
9692        pub use crate::RouteRequest;
9693
9694        pub use crate::RouterError;
9695    }
9696
9697    pub struct Route;
9698
9699    impl ::fidl_next::Method for Route {
9700        const ORDINAL: u64 = 8420527046218942310;
9701
9702        type Protocol = crate::ConnectorRouter;
9703
9704        type Request = crate::WireRouteRequest<'static>;
9705
9706        type Response = ::fidl_next::WireFlexibleResult<
9707            'static,
9708            crate::WireConnectorRouterRouteResponse,
9709            crate::WireRouterError,
9710        >;
9711    }
9712
9713    mod ___detail {
9714
9715        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::ConnectorRouter
9716        where
9717            ___T: ::fidl_next::Transport,
9718        {
9719            type Client = ConnectorRouterClient<___T>;
9720            type Server = ConnectorRouterServer<___T>;
9721        }
9722
9723        /// The client for the `ConnectorRouter` protocol.
9724        #[repr(transparent)]
9725        pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
9726            #[allow(dead_code)]
9727            client: ::fidl_next::protocol::Client<___T>,
9728        }
9729
9730        impl<___T> ConnectorRouterClient<___T>
9731        where
9732            ___T: ::fidl_next::Transport,
9733        {
9734            pub fn route_with<___R>(
9735                &self,
9736                request: ___R,
9737            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
9738            where
9739                ___R: ::fidl_next::Encode<
9740                        <___T as ::fidl_next::Transport>::SendBuffer,
9741                        Encoded = crate::WireRouteRequest<'static>,
9742                    >,
9743            {
9744                ::fidl_next::TwoWayFuture::from_untyped(
9745                    self.client.send_two_way(8420527046218942310, request),
9746                )
9747            }
9748        }
9749
9750        /// The server for the `ConnectorRouter` protocol.
9751        #[repr(transparent)]
9752        pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
9753            server: ::fidl_next::protocol::Server<___T>,
9754        }
9755
9756        impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
9757    }
9758}
9759
9760/// A client handler for the ConnectorRouter protocol.
9761///
9762/// See [`ConnectorRouter`] for more details.
9763pub trait ConnectorRouterClientHandler<
9764    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
9765    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9766>
9767{
9768    fn on_unknown_interaction(
9769        &mut self,
9770        ordinal: u64,
9771    ) -> impl ::core::future::Future<
9772        Output = ::core::result::Result<
9773            (),
9774            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9775        >,
9776    > + ::core::marker::Send {
9777        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
9778    }
9779}
9780
9781impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
9782where
9783    ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
9784    ___T: ::fidl_next::Transport,
9785    <connector_router::Route as ::fidl_next::Method>::Response:
9786        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9787{
9788    async fn on_event(
9789        handler: &mut ___H,
9790        ordinal: u64,
9791        buffer: ___T::RecvBuffer,
9792    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9793        match ordinal {
9794            ordinal => handler.on_unknown_interaction(ordinal).await,
9795        }
9796    }
9797}
9798
9799/// A server handler for the ConnectorRouter protocol.
9800///
9801/// See [`ConnectorRouter`] for more details.
9802pub trait ConnectorRouterServerHandler<
9803    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
9804    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9805>
9806{
9807    fn route(
9808        &mut self,
9809
9810        request: ::fidl_next::Request<connector_router::Route, ___T>,
9811
9812        responder: ::fidl_next::Responder<connector_router::Route, ___T>,
9813    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9814
9815    fn on_unknown_interaction(
9816        &mut self,
9817        ordinal: u64,
9818    ) -> impl ::core::future::Future<
9819        Output = ::core::result::Result<
9820            (),
9821            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9822        >,
9823    > + ::core::marker::Send {
9824        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
9825    }
9826}
9827
9828impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
9829where
9830    ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
9831    ___T: ::fidl_next::Transport,
9832    <connector_router::Route as ::fidl_next::Method>::Request:
9833        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
9834{
9835    async fn on_one_way(
9836        handler: &mut ___H,
9837        ordinal: u64,
9838        buffer: ___T::RecvBuffer,
9839    ) -> ::core::result::Result<
9840        (),
9841        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9842    > {
9843        match ordinal {
9844            ordinal => handler.on_unknown_interaction(ordinal).await,
9845        }
9846    }
9847
9848    async fn on_two_way(
9849        handler: &mut ___H,
9850        ordinal: u64,
9851        buffer: ___T::RecvBuffer,
9852        responder: ::fidl_next::protocol::Responder<___T>,
9853    ) -> ::core::result::Result<
9854        (),
9855        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9856    > {
9857        match ordinal {
9858            8420527046218942310 => {
9859                let responder = ::fidl_next::Responder::from_untyped(responder);
9860
9861                match ::fidl_next::DecoderExt::decode(buffer) {
9862                    Ok(decoded) => {
9863                        handler.route(decoded, responder).await;
9864                        Ok(())
9865                    }
9866                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9867                        ordinal: 8420527046218942310,
9868                        error,
9869                    }),
9870                }
9871            }
9872
9873            ordinal => handler.on_unknown_interaction(ordinal).await,
9874        }
9875    }
9876}
9877
9878#[derive(PartialEq, Debug)]
9879pub enum DataRouterRouteResponse {
9880    Data(crate::Data),
9881
9882    Unavailable(crate::Unit),
9883}
9884
9885impl ::fidl_next::Encodable for DataRouterRouteResponse {
9886    type Encoded = WireDataRouterRouteResponse<'static>;
9887}
9888
9889unsafe impl<___E> ::fidl_next::Encode<___E> for DataRouterRouteResponse
9890where
9891    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9892    ___E: ::fidl_next::Encoder,
9893    ___E: ::fidl_next::fuchsia::HandleEncoder,
9894{
9895    #[inline]
9896    fn encode(
9897        self,
9898        encoder: &mut ___E,
9899        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
9900    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9901        ::fidl_next::munge!(let WireDataRouterRouteResponse { raw, _phantom: _ } = out);
9902
9903        match self {
9904            Self::Data(value) => {
9905                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Data>(value, 1, encoder, raw)?
9906            }
9907
9908            Self::Unavailable(value) => {
9909                ::fidl_next::RawWireUnion::encode_as::<___E, crate::Unit>(value, 2, encoder, raw)?
9910            }
9911        }
9912
9913        Ok(())
9914    }
9915}
9916
9917impl ::fidl_next::EncodableOption for DataRouterRouteResponse {
9918    type EncodedOption = WireOptionalDataRouterRouteResponse<'static>;
9919}
9920
9921unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DataRouterRouteResponse
9922where
9923    ___E: ?Sized,
9924    DataRouterRouteResponse: ::fidl_next::Encode<___E>,
9925{
9926    #[inline]
9927    fn encode_option(
9928        this: ::core::option::Option<Self>,
9929        encoder: &mut ___E,
9930        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
9931    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9932        ::fidl_next::munge!(let WireOptionalDataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
9933
9934        if let Some(inner) = this {
9935            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
9936            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
9937        } else {
9938            ::fidl_next::RawWireUnion::encode_absent(raw);
9939        }
9940
9941        Ok(())
9942    }
9943}
9944
9945impl<'de> ::fidl_next::FromWire<WireDataRouterRouteResponse<'de>> for DataRouterRouteResponse {
9946    #[inline]
9947    fn from_wire(wire: WireDataRouterRouteResponse<'de>) -> Self {
9948        let wire = ::core::mem::ManuallyDrop::new(wire);
9949        match wire.raw.ordinal() {
9950            1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
9951                wire.raw.get().read_unchecked::<crate::WireData<'de>>()
9952            })),
9953
9954            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
9955                wire.raw.get().read_unchecked::<crate::WireUnit>()
9956            })),
9957
9958            _ => unsafe { ::core::hint::unreachable_unchecked() },
9959        }
9960    }
9961}
9962
9963impl<'de> ::fidl_next::IntoNatural for WireDataRouterRouteResponse<'de> {
9964    type Natural = DataRouterRouteResponse;
9965}
9966
9967impl<'de> ::fidl_next::FromWireOption<WireOptionalDataRouterRouteResponse<'de>>
9968    for DataRouterRouteResponse
9969{
9970    #[inline]
9971    fn from_wire_option(
9972        wire: WireOptionalDataRouterRouteResponse<'de>,
9973    ) -> ::core::option::Option<Self> {
9974        if let Some(inner) = wire.into_option() {
9975            Some(::fidl_next::FromWire::from_wire(inner))
9976        } else {
9977            None
9978        }
9979    }
9980}
9981
9982impl<'de> ::fidl_next::IntoNatural for WireOptionalDataRouterRouteResponse<'de> {
9983    type Natural = ::core::option::Option<DataRouterRouteResponse>;
9984}
9985
9986impl<'de> ::fidl_next::FromWireOption<WireOptionalDataRouterRouteResponse<'de>>
9987    for Box<DataRouterRouteResponse>
9988{
9989    #[inline]
9990    fn from_wire_option(
9991        wire: WireOptionalDataRouterRouteResponse<'de>,
9992    ) -> ::core::option::Option<Self> {
9993        <DataRouterRouteResponse as ::fidl_next::FromWireOption<
9994            WireOptionalDataRouterRouteResponse<'de>,
9995        >>::from_wire_option(wire)
9996        .map(Box::new)
9997    }
9998}
9999
10000/// The wire type corresponding to [`DataRouterRouteResponse`].
10001#[repr(transparent)]
10002pub struct WireDataRouterRouteResponse<'de> {
10003    raw: ::fidl_next::RawWireUnion,
10004    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
10005}
10006
10007impl<'de> Drop for WireDataRouterRouteResponse<'de> {
10008    fn drop(&mut self) {
10009        match self.raw.ordinal() {
10010            1 => {
10011                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireData<'de>>() };
10012            }
10013
10014            2 => {
10015                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
10016            }
10017
10018            _ => unsafe { ::core::hint::unreachable_unchecked() },
10019        }
10020    }
10021}
10022
10023unsafe impl ::fidl_next::Wire for WireDataRouterRouteResponse<'static> {
10024    type Decoded<'de> = WireDataRouterRouteResponse<'de>;
10025
10026    #[inline]
10027    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10028        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
10029        ::fidl_next::RawWireUnion::zero_padding(raw);
10030    }
10031}
10032
10033pub mod data_router_route_response {
10034    pub enum Ref<'de> {
10035        Data(&'de crate::WireData<'de>),
10036
10037        Unavailable(&'de crate::WireUnit),
10038    }
10039}
10040
10041impl<'de> WireDataRouterRouteResponse<'de> {
10042    pub fn as_ref(&self) -> crate::data_router_route_response::Ref<'_> {
10043        match self.raw.ordinal() {
10044            1 => crate::data_router_route_response::Ref::Data(unsafe {
10045                self.raw.get().deref_unchecked::<crate::WireData<'_>>()
10046            }),
10047
10048            2 => crate::data_router_route_response::Ref::Unavailable(unsafe {
10049                self.raw.get().deref_unchecked::<crate::WireUnit>()
10050            }),
10051
10052            _ => unsafe { ::core::hint::unreachable_unchecked() },
10053        }
10054    }
10055}
10056
10057unsafe impl<___D> ::fidl_next::Decode<___D> for WireDataRouterRouteResponse<'static>
10058where
10059    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10060    ___D: ::fidl_next::Decoder,
10061    ___D: ::fidl_next::fuchsia::HandleDecoder,
10062{
10063    fn decode(
10064        mut slot: ::fidl_next::Slot<'_, Self>,
10065        decoder: &mut ___D,
10066    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10067        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
10068        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
10069            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
10070                raw, decoder,
10071            )?,
10072
10073            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
10074
10075            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
10076        }
10077
10078        Ok(())
10079    }
10080}
10081
10082impl<'de> ::core::fmt::Debug for WireDataRouterRouteResponse<'de> {
10083    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10084        match self.raw.ordinal() {
10085            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireData<'_>>().fmt(f) },
10086            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
10087            _ => unsafe { ::core::hint::unreachable_unchecked() },
10088        }
10089    }
10090}
10091
10092#[repr(transparent)]
10093pub struct WireOptionalDataRouterRouteResponse<'de> {
10094    raw: ::fidl_next::RawWireUnion,
10095    _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
10096}
10097
10098unsafe impl ::fidl_next::Wire for WireOptionalDataRouterRouteResponse<'static> {
10099    type Decoded<'de> = WireOptionalDataRouterRouteResponse<'de>;
10100
10101    #[inline]
10102    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10103        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
10104        ::fidl_next::RawWireUnion::zero_padding(raw);
10105    }
10106}
10107
10108impl<'de> WireOptionalDataRouterRouteResponse<'de> {
10109    pub fn is_some(&self) -> bool {
10110        self.raw.is_some()
10111    }
10112
10113    pub fn is_none(&self) -> bool {
10114        self.raw.is_none()
10115    }
10116
10117    pub fn as_ref(&self) -> ::core::option::Option<&WireDataRouterRouteResponse<'de>> {
10118        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
10119    }
10120
10121    pub fn into_option(self) -> ::core::option::Option<WireDataRouterRouteResponse<'de>> {
10122        if self.is_some() {
10123            Some(WireDataRouterRouteResponse {
10124                raw: self.raw,
10125                _phantom: ::core::marker::PhantomData,
10126            })
10127        } else {
10128            None
10129        }
10130    }
10131}
10132
10133unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDataRouterRouteResponse<'static>
10134where
10135    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10136    ___D: ::fidl_next::Decoder,
10137    ___D: ::fidl_next::fuchsia::HandleDecoder,
10138{
10139    fn decode(
10140        mut slot: ::fidl_next::Slot<'_, Self>,
10141        decoder: &mut ___D,
10142    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10143        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
10144        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
10145            1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireData<'static>>(
10146                raw, decoder,
10147            )?,
10148
10149            2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::WireUnit>(raw, decoder)?,
10150
10151            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
10152            _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
10153        }
10154
10155        Ok(())
10156    }
10157}
10158
10159impl<'de> ::core::fmt::Debug for WireOptionalDataRouterRouteResponse<'de> {
10160    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
10161        self.as_ref().fmt(f)
10162    }
10163}
10164
10165/// The type corresponding to the DataRouter protocol.
10166#[derive(PartialEq, Debug)]
10167pub struct DataRouter;
10168
10169impl ::fidl_next::Discoverable for DataRouter {
10170    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
10171}
10172
10173pub mod data_router {
10174    pub mod prelude {
10175        pub use crate::{
10176            DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
10177        };
10178
10179        pub use crate::DataRouterRouteResponse;
10180
10181        pub use crate::RouteRequest;
10182
10183        pub use crate::RouterError;
10184    }
10185
10186    pub struct Route;
10187
10188    impl ::fidl_next::Method for Route {
10189        const ORDINAL: u64 = 3352890635970754564;
10190
10191        type Protocol = crate::DataRouter;
10192
10193        type Request = crate::WireRouteRequest<'static>;
10194
10195        type Response = ::fidl_next::WireFlexibleResult<
10196            'static,
10197            crate::WireDataRouterRouteResponse<'static>,
10198            crate::WireRouterError,
10199        >;
10200    }
10201
10202    mod ___detail {
10203
10204        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DataRouter
10205        where
10206            ___T: ::fidl_next::Transport,
10207        {
10208            type Client = DataRouterClient<___T>;
10209            type Server = DataRouterServer<___T>;
10210        }
10211
10212        /// The client for the `DataRouter` protocol.
10213        #[repr(transparent)]
10214        pub struct DataRouterClient<___T: ::fidl_next::Transport> {
10215            #[allow(dead_code)]
10216            client: ::fidl_next::protocol::Client<___T>,
10217        }
10218
10219        impl<___T> DataRouterClient<___T>
10220        where
10221            ___T: ::fidl_next::Transport,
10222        {
10223            pub fn route_with<___R>(
10224                &self,
10225                request: ___R,
10226            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
10227            where
10228                ___R: ::fidl_next::Encode<
10229                        <___T as ::fidl_next::Transport>::SendBuffer,
10230                        Encoded = crate::WireRouteRequest<'static>,
10231                    >,
10232            {
10233                ::fidl_next::TwoWayFuture::from_untyped(
10234                    self.client.send_two_way(3352890635970754564, request),
10235                )
10236            }
10237        }
10238
10239        /// The server for the `DataRouter` protocol.
10240        #[repr(transparent)]
10241        pub struct DataRouterServer<___T: ::fidl_next::Transport> {
10242            server: ::fidl_next::protocol::Server<___T>,
10243        }
10244
10245        impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
10246    }
10247}
10248
10249/// A client handler for the DataRouter protocol.
10250///
10251/// See [`DataRouter`] for more details.
10252pub trait DataRouterClientHandler<
10253    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10254    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10255>
10256{
10257    fn on_unknown_interaction(
10258        &mut self,
10259        ordinal: u64,
10260    ) -> impl ::core::future::Future<
10261        Output = ::core::result::Result<
10262            (),
10263            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10264        >,
10265    > + ::core::marker::Send {
10266        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10267    }
10268}
10269
10270impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
10271where
10272    ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
10273    ___T: ::fidl_next::Transport,
10274    <data_router::Route as ::fidl_next::Method>::Response:
10275        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10276{
10277    async fn on_event(
10278        handler: &mut ___H,
10279        ordinal: u64,
10280        buffer: ___T::RecvBuffer,
10281    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10282        match ordinal {
10283            ordinal => handler.on_unknown_interaction(ordinal).await,
10284        }
10285    }
10286}
10287
10288/// A server handler for the DataRouter protocol.
10289///
10290/// See [`DataRouter`] for more details.
10291pub trait DataRouterServerHandler<
10292    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10293    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10294>
10295{
10296    fn route(
10297        &mut self,
10298
10299        request: ::fidl_next::Request<data_router::Route, ___T>,
10300
10301        responder: ::fidl_next::Responder<data_router::Route, ___T>,
10302    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10303
10304    fn on_unknown_interaction(
10305        &mut self,
10306        ordinal: u64,
10307    ) -> impl ::core::future::Future<
10308        Output = ::core::result::Result<
10309            (),
10310            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10311        >,
10312    > + ::core::marker::Send {
10313        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10314    }
10315}
10316
10317impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
10318where
10319    ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
10320    ___T: ::fidl_next::Transport,
10321    <data_router::Route as ::fidl_next::Method>::Request:
10322        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
10323{
10324    async fn on_one_way(
10325        handler: &mut ___H,
10326        ordinal: u64,
10327        buffer: ___T::RecvBuffer,
10328    ) -> ::core::result::Result<
10329        (),
10330        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10331    > {
10332        match ordinal {
10333            ordinal => handler.on_unknown_interaction(ordinal).await,
10334        }
10335    }
10336
10337    async fn on_two_way(
10338        handler: &mut ___H,
10339        ordinal: u64,
10340        buffer: ___T::RecvBuffer,
10341        responder: ::fidl_next::protocol::Responder<___T>,
10342    ) -> ::core::result::Result<
10343        (),
10344        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10345    > {
10346        match ordinal {
10347            3352890635970754564 => {
10348                let responder = ::fidl_next::Responder::from_untyped(responder);
10349
10350                match ::fidl_next::DecoderExt::decode(buffer) {
10351                    Ok(decoded) => {
10352                        handler.route(decoded, responder).await;
10353                        Ok(())
10354                    }
10355                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10356                        ordinal: 3352890635970754564,
10357                        error,
10358                    }),
10359                }
10360            }
10361
10362            ordinal => handler.on_unknown_interaction(ordinal).await,
10363        }
10364    }
10365}
10366
10367/// The type corresponding to the Dictionary protocol.
10368#[derive(PartialEq, Debug)]
10369pub struct Dictionary;
10370
10371impl ::fidl_next::Discoverable for Dictionary {
10372    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
10373}
10374
10375pub mod dictionary {
10376    pub mod prelude {
10377        pub use crate::{Dictionary, DictionaryClientHandler, DictionaryServerHandler, dictionary};
10378    }
10379
10380    mod ___detail {
10381
10382        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Dictionary
10383        where
10384            ___T: ::fidl_next::Transport,
10385        {
10386            type Client = DictionaryClient<___T>;
10387            type Server = DictionaryServer<___T>;
10388        }
10389
10390        /// The client for the `Dictionary` protocol.
10391        #[repr(transparent)]
10392        pub struct DictionaryClient<___T: ::fidl_next::Transport> {
10393            #[allow(dead_code)]
10394            client: ::fidl_next::protocol::Client<___T>,
10395        }
10396
10397        impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
10398
10399        /// The server for the `Dictionary` protocol.
10400        #[repr(transparent)]
10401        pub struct DictionaryServer<___T: ::fidl_next::Transport> {
10402            server: ::fidl_next::protocol::Server<___T>,
10403        }
10404
10405        impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
10406    }
10407}
10408
10409/// A client handler for the Dictionary protocol.
10410///
10411/// See [`Dictionary`] for more details.
10412pub trait DictionaryClientHandler<
10413    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10414    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10415>
10416{
10417    fn on_unknown_interaction(
10418        &mut self,
10419        ordinal: u64,
10420    ) -> impl ::core::future::Future<
10421        Output = ::core::result::Result<
10422            (),
10423            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10424        >,
10425    > + ::core::marker::Send {
10426        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10427    }
10428}
10429
10430impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
10431where
10432    ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
10433    ___T: ::fidl_next::Transport,
10434{
10435    async fn on_event(
10436        handler: &mut ___H,
10437        ordinal: u64,
10438        buffer: ___T::RecvBuffer,
10439    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10440        match ordinal {
10441            ordinal => handler.on_unknown_interaction(ordinal).await,
10442        }
10443    }
10444}
10445
10446/// A server handler for the Dictionary protocol.
10447///
10448/// See [`Dictionary`] for more details.
10449pub trait DictionaryServerHandler<
10450    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
10451    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10452>
10453{
10454    fn on_unknown_interaction(
10455        &mut self,
10456        ordinal: u64,
10457    ) -> impl ::core::future::Future<
10458        Output = ::core::result::Result<
10459            (),
10460            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10461        >,
10462    > + ::core::marker::Send {
10463        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
10464    }
10465}
10466
10467impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
10468where
10469    ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
10470    ___T: ::fidl_next::Transport,
10471{
10472    async fn on_one_way(
10473        handler: &mut ___H,
10474        ordinal: u64,
10475        buffer: ___T::RecvBuffer,
10476    ) -> ::core::result::Result<
10477        (),
10478        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10479    > {
10480        match ordinal {
10481            ordinal => handler.on_unknown_interaction(ordinal).await,
10482        }
10483    }
10484
10485    async fn on_two_way(
10486        handler: &mut ___H,
10487        ordinal: u64,
10488        buffer: ___T::RecvBuffer,
10489        responder: ::fidl_next::protocol::Responder<___T>,
10490    ) -> ::core::result::Result<
10491        (),
10492        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10493    > {
10494        match ordinal {
10495            ordinal => handler.on_unknown_interaction(ordinal).await,
10496        }
10497    }
10498}
10499
10500#[derive(PartialEq, Clone, Debug)]
10501pub struct DictionaryDrainIteratorGetNextRequest {
10502    pub start_id: u64,
10503
10504    pub limit: u32,
10505}
10506
10507impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest {
10508    type Encoded = WireDictionaryDrainIteratorGetNextRequest;
10509}
10510
10511unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextRequest
10512where
10513    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10514{
10515    #[inline]
10516    fn encode(
10517        self,
10518        encoder_: &mut ___E,
10519        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10520    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10521        ::fidl_next::munge! {
10522            let Self::Encoded {
10523                start_id,
10524                limit,
10525
10526            } = out_;
10527        }
10528
10529        ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
10530
10531        ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
10532
10533        Ok(())
10534    }
10535}
10536
10537unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryDrainIteratorGetNextRequest
10538where
10539    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10540{
10541    #[inline]
10542    fn encode_ref(
10543        &self,
10544        encoder_: &mut ___E,
10545        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10546    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10547        ::fidl_next::munge! {
10548            let Self::Encoded {
10549
10550                start_id,
10551                limit,
10552
10553            } = out_;
10554        }
10555
10556        ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id)?;
10557
10558        ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit)?;
10559
10560        Ok(())
10561    }
10562}
10563
10564impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextRequest {
10565    type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryDrainIteratorGetNextRequest>;
10566}
10567
10568unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextRequest
10569where
10570    ___E: ::fidl_next::Encoder + ?Sized,
10571    DictionaryDrainIteratorGetNextRequest: ::fidl_next::Encode<___E>,
10572{
10573    #[inline]
10574    fn encode_option(
10575        this: ::core::option::Option<Self>,
10576        encoder: &mut ___E,
10577        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10578    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10579        if let Some(inner) = this {
10580            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10581            ::fidl_next::WireBox::encode_present(out);
10582        } else {
10583            ::fidl_next::WireBox::encode_absent(out);
10584        }
10585
10586        Ok(())
10587    }
10588}
10589
10590unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryDrainIteratorGetNextRequest
10591where
10592    ___E: ::fidl_next::Encoder + ?Sized,
10593    DictionaryDrainIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
10594{
10595    #[inline]
10596    fn encode_option_ref(
10597        this: ::core::option::Option<&Self>,
10598        encoder: &mut ___E,
10599        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10600    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10601        if let Some(inner) = this {
10602            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10603            ::fidl_next::WireBox::encode_present(out);
10604        } else {
10605            ::fidl_next::WireBox::encode_absent(out);
10606        }
10607
10608        Ok(())
10609    }
10610}
10611
10612impl ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextRequest>
10613    for DictionaryDrainIteratorGetNextRequest
10614{
10615    #[inline]
10616    fn from_wire(wire: WireDictionaryDrainIteratorGetNextRequest) -> Self {
10617        Self {
10618            start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
10619
10620            limit: ::fidl_next::FromWire::from_wire(wire.limit),
10621        }
10622    }
10623}
10624
10625impl ::fidl_next::IntoNatural for WireDictionaryDrainIteratorGetNextRequest {
10626    type Natural = DictionaryDrainIteratorGetNextRequest;
10627}
10628
10629impl ::fidl_next::FromWireRef<WireDictionaryDrainIteratorGetNextRequest>
10630    for DictionaryDrainIteratorGetNextRequest
10631{
10632    #[inline]
10633    fn from_wire_ref(wire: &WireDictionaryDrainIteratorGetNextRequest) -> Self {
10634        Self {
10635            start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
10636
10637            limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
10638        }
10639    }
10640}
10641
10642/// The wire type corresponding to [`DictionaryDrainIteratorGetNextRequest`].
10643#[derive(Clone, Debug)]
10644#[repr(C)]
10645pub struct WireDictionaryDrainIteratorGetNextRequest {
10646    pub start_id: ::fidl_next::WireU64,
10647
10648    pub limit: ::fidl_next::WireU32,
10649}
10650static_assertions::const_assert_eq!(
10651    std::mem::size_of::<WireDictionaryDrainIteratorGetNextRequest>(),
10652    16
10653);
10654static_assertions::const_assert_eq!(
10655    std::mem::align_of::<WireDictionaryDrainIteratorGetNextRequest>(),
10656    8
10657);
10658
10659static_assertions::const_assert_eq!(
10660    std::mem::offset_of!(WireDictionaryDrainIteratorGetNextRequest, start_id),
10661    0
10662);
10663
10664static_assertions::const_assert_eq!(
10665    std::mem::offset_of!(WireDictionaryDrainIteratorGetNextRequest, limit),
10666    8
10667);
10668
10669unsafe impl ::fidl_next::Wire for WireDictionaryDrainIteratorGetNextRequest {
10670    type Decoded<'de> = WireDictionaryDrainIteratorGetNextRequest;
10671
10672    #[inline]
10673    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10674        ::fidl_next::munge! {
10675            let Self {
10676
10677                start_id,
10678                limit,
10679
10680            } = &mut *out_;
10681        }
10682
10683        ::fidl_next::Wire::zero_padding(start_id);
10684
10685        ::fidl_next::Wire::zero_padding(limit);
10686
10687        unsafe {
10688            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10689        }
10690    }
10691}
10692
10693unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextRequest
10694where
10695    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10696{
10697    fn decode(
10698        slot_: ::fidl_next::Slot<'_, Self>,
10699        decoder_: &mut ___D,
10700    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10701        ::fidl_next::munge! {
10702            let Self {
10703
10704                mut start_id,
10705                mut limit,
10706
10707            } = slot_;
10708        }
10709
10710        ::fidl_next::Decode::decode(start_id.as_mut(), decoder_)?;
10711
10712        ::fidl_next::Decode::decode(limit.as_mut(), decoder_)?;
10713
10714        Ok(())
10715    }
10716}
10717
10718#[doc = " Maximum number of items returned by dictionary iterator.\n"]
10719pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;
10720
10721#[derive(PartialEq, Debug)]
10722pub struct DictionaryDrainIteratorGetNextResponse {
10723    pub items: ::std::vec::Vec<crate::DictionaryItem>,
10724
10725    pub end_id: u64,
10726}
10727
10728impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse {
10729    type Encoded = WireDictionaryDrainIteratorGetNextResponse<'static>;
10730}
10731
10732unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextResponse
10733where
10734    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10735    ___E: ::fidl_next::Encoder,
10736    ___E: ::fidl_next::fuchsia::HandleEncoder,
10737{
10738    #[inline]
10739    fn encode(
10740        self,
10741        encoder_: &mut ___E,
10742        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10743    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10744        ::fidl_next::munge! {
10745            let Self::Encoded {
10746                items,
10747                end_id,
10748
10749            } = out_;
10750        }
10751
10752        ::fidl_next::Encode::encode(self.items, encoder_, items)?;
10753
10754        ::fidl_next::Encode::encode(self.end_id, encoder_, end_id)?;
10755
10756        Ok(())
10757    }
10758}
10759
10760impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextResponse {
10761    type EncodedOption =
10762        ::fidl_next::WireBox<'static, WireDictionaryDrainIteratorGetNextResponse<'static>>;
10763}
10764
10765unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextResponse
10766where
10767    ___E: ::fidl_next::Encoder + ?Sized,
10768    DictionaryDrainIteratorGetNextResponse: ::fidl_next::Encode<___E>,
10769{
10770    #[inline]
10771    fn encode_option(
10772        this: ::core::option::Option<Self>,
10773        encoder: &mut ___E,
10774        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
10775    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10776        if let Some(inner) = this {
10777            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10778            ::fidl_next::WireBox::encode_present(out);
10779        } else {
10780            ::fidl_next::WireBox::encode_absent(out);
10781        }
10782
10783        Ok(())
10784    }
10785}
10786
10787impl<'de> ::fidl_next::FromWire<WireDictionaryDrainIteratorGetNextResponse<'de>>
10788    for DictionaryDrainIteratorGetNextResponse
10789{
10790    #[inline]
10791    fn from_wire(wire: WireDictionaryDrainIteratorGetNextResponse<'de>) -> Self {
10792        Self {
10793            items: ::fidl_next::FromWire::from_wire(wire.items),
10794
10795            end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
10796        }
10797    }
10798}
10799
10800impl<'de> ::fidl_next::IntoNatural for WireDictionaryDrainIteratorGetNextResponse<'de> {
10801    type Natural = DictionaryDrainIteratorGetNextResponse;
10802}
10803
10804/// The wire type corresponding to [`DictionaryDrainIteratorGetNextResponse`].
10805#[derive(Debug)]
10806#[repr(C)]
10807pub struct WireDictionaryDrainIteratorGetNextResponse<'de> {
10808    pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryItem<'de>>,
10809
10810    pub end_id: ::fidl_next::WireU64,
10811}
10812static_assertions::const_assert_eq!(
10813    std::mem::size_of::<WireDictionaryDrainIteratorGetNextResponse<'_>>(),
10814    24
10815);
10816static_assertions::const_assert_eq!(
10817    std::mem::align_of::<WireDictionaryDrainIteratorGetNextResponse<'_>>(),
10818    8
10819);
10820
10821static_assertions::const_assert_eq!(
10822    std::mem::offset_of!(WireDictionaryDrainIteratorGetNextResponse<'_>, items),
10823    0
10824);
10825
10826static_assertions::const_assert_eq!(
10827    std::mem::offset_of!(WireDictionaryDrainIteratorGetNextResponse<'_>, end_id),
10828    16
10829);
10830
10831unsafe impl ::fidl_next::Wire for WireDictionaryDrainIteratorGetNextResponse<'static> {
10832    type Decoded<'de> = WireDictionaryDrainIteratorGetNextResponse<'de>;
10833
10834    #[inline]
10835    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10836        ::fidl_next::munge! {
10837            let Self {
10838
10839                items,
10840                end_id,
10841
10842            } = &mut *out_;
10843        }
10844
10845        ::fidl_next::Wire::zero_padding(items);
10846
10847        ::fidl_next::Wire::zero_padding(end_id);
10848    }
10849}
10850
10851unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryDrainIteratorGetNextResponse<'static>
10852where
10853    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10854    ___D: ::fidl_next::Decoder,
10855    ___D: ::fidl_next::fuchsia::HandleDecoder,
10856{
10857    fn decode(
10858        slot_: ::fidl_next::Slot<'_, Self>,
10859        decoder_: &mut ___D,
10860    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10861        ::fidl_next::munge! {
10862            let Self {
10863
10864                mut items,
10865                mut end_id,
10866
10867            } = slot_;
10868        }
10869
10870        ::fidl_next::Decode::decode(items.as_mut(), decoder_)?;
10871
10872        let items = unsafe { items.deref_unchecked() };
10873
10874        if items.len() > 128 {
10875            return Err(::fidl_next::DecodeError::VectorTooLong {
10876                size: items.len() as u64,
10877                limit: 128,
10878            });
10879        }
10880
10881        ::fidl_next::Decode::decode(end_id.as_mut(), decoder_)?;
10882
10883        Ok(())
10884    }
10885}
10886
10887/// The type corresponding to the DictionaryDrainIterator protocol.
10888#[derive(PartialEq, Debug)]
10889pub struct DictionaryDrainIterator;
10890
10891pub mod dictionary_drain_iterator {
10892    pub mod prelude {
10893        pub use crate::{
10894            DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
10895            DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
10896        };
10897
10898        pub use crate::CapabilityStoreError;
10899
10900        pub use crate::DictionaryDrainIteratorGetNextRequest;
10901
10902        pub use crate::DictionaryDrainIteratorGetNextResponse;
10903    }
10904
10905    pub struct GetNext;
10906
10907    impl ::fidl_next::Method for GetNext {
10908        const ORDINAL: u64 = 5728722530628427873;
10909
10910        type Protocol = crate::DictionaryDrainIterator;
10911
10912        type Request = crate::WireDictionaryDrainIteratorGetNextRequest;
10913
10914        type Response = ::fidl_next::WireFlexibleResult<
10915            'static,
10916            crate::WireDictionaryDrainIteratorGetNextResponse<'static>,
10917            crate::WireCapabilityStoreError,
10918        >;
10919    }
10920
10921    mod ___detail {
10922
10923        pub struct GetNext<T0, T1> {
10924            start_id: T0,
10925
10926            limit: T1,
10927        }
10928
10929        impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
10930        where
10931            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
10932            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
10933        {
10934            type Encoded = crate::WireDictionaryDrainIteratorGetNextRequest;
10935        }
10936
10937        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for GetNext<T0, T1>
10938        where
10939            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10940            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
10941            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
10942        {
10943            #[inline]
10944            fn encode(
10945                self,
10946                encoder_: &mut ___E,
10947                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
10948            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10949                ::fidl_next::munge! {
10950                    let Self::Encoded {
10951                        start_id,
10952                        limit,
10953
10954                    } = out_;
10955                }
10956
10957                ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
10958
10959                ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
10960
10961                Ok(())
10962            }
10963        }
10964
10965        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryDrainIterator
10966        where
10967            ___T: ::fidl_next::Transport,
10968        {
10969            type Client = DictionaryDrainIteratorClient<___T>;
10970            type Server = DictionaryDrainIteratorServer<___T>;
10971        }
10972
10973        /// The client for the `DictionaryDrainIterator` protocol.
10974        #[repr(transparent)]
10975        pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
10976            #[allow(dead_code)]
10977            client: ::fidl_next::protocol::Client<___T>,
10978        }
10979
10980        impl<___T> DictionaryDrainIteratorClient<___T>
10981        where
10982            ___T: ::fidl_next::Transport,
10983        {
10984            #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
10985            pub fn get_next(
10986                &self,
10987
10988                start_id: impl ::fidl_next::Encode<
10989                    <___T as ::fidl_next::Transport>::SendBuffer,
10990                    Encoded = ::fidl_next::WireU64,
10991                >,
10992
10993                limit: impl ::fidl_next::Encode<
10994                    <___T as ::fidl_next::Transport>::SendBuffer,
10995                    Encoded = ::fidl_next::WireU32,
10996                >,
10997            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
10998            where
10999                <___T as ::fidl_next::Transport>::SendBuffer:
11000                    ::fidl_next::encoder::InternalHandleEncoder,
11001            {
11002                self.get_next_with(GetNext { start_id, limit })
11003            }
11004
11005            #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
11006            pub fn get_next_with<___R>(
11007                &self,
11008                request: ___R,
11009            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11010            where
11011                ___R: ::fidl_next::Encode<
11012                        <___T as ::fidl_next::Transport>::SendBuffer,
11013                        Encoded = crate::WireDictionaryDrainIteratorGetNextRequest,
11014                    >,
11015            {
11016                ::fidl_next::TwoWayFuture::from_untyped(
11017                    self.client.send_two_way(5728722530628427873, request),
11018                )
11019            }
11020        }
11021
11022        /// The server for the `DictionaryDrainIterator` protocol.
11023        #[repr(transparent)]
11024        pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
11025            server: ::fidl_next::protocol::Server<___T>,
11026        }
11027
11028        impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11029    }
11030}
11031
11032/// A client handler for the DictionaryDrainIterator protocol.
11033///
11034/// See [`DictionaryDrainIterator`] for more details.
11035pub trait DictionaryDrainIteratorClientHandler<
11036    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11037    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11038>
11039{
11040    fn on_unknown_interaction(
11041        &mut self,
11042        ordinal: u64,
11043    ) -> impl ::core::future::Future<
11044        Output = ::core::result::Result<
11045            (),
11046            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11047        >,
11048    > + ::core::marker::Send {
11049        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11050    }
11051}
11052
11053impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
11054where
11055    ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
11056    ___T: ::fidl_next::Transport,
11057    <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Response:
11058        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11059{
11060    async fn on_event(
11061        handler: &mut ___H,
11062        ordinal: u64,
11063        buffer: ___T::RecvBuffer,
11064    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11065        match ordinal {
11066            ordinal => handler.on_unknown_interaction(ordinal).await,
11067        }
11068    }
11069}
11070
11071/// A server handler for the DictionaryDrainIterator protocol.
11072///
11073/// See [`DictionaryDrainIterator`] for more details.
11074pub trait DictionaryDrainIteratorServerHandler<
11075    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11076    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11077>
11078{
11079    #[doc = " Returns the next batch of results for a [Dictionary.Drain] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
11080    fn get_next(
11081        &mut self,
11082
11083        request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
11084
11085        responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
11086    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11087
11088    fn on_unknown_interaction(
11089        &mut self,
11090        ordinal: u64,
11091    ) -> impl ::core::future::Future<
11092        Output = ::core::result::Result<
11093            (),
11094            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11095        >,
11096    > + ::core::marker::Send {
11097        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11098    }
11099}
11100
11101impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
11102where
11103    ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
11104    ___T: ::fidl_next::Transport,
11105    <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
11106        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11107{
11108    async fn on_one_way(
11109        handler: &mut ___H,
11110        ordinal: u64,
11111        buffer: ___T::RecvBuffer,
11112    ) -> ::core::result::Result<
11113        (),
11114        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11115    > {
11116        match ordinal {
11117            ordinal => handler.on_unknown_interaction(ordinal).await,
11118        }
11119    }
11120
11121    async fn on_two_way(
11122        handler: &mut ___H,
11123        ordinal: u64,
11124        buffer: ___T::RecvBuffer,
11125        responder: ::fidl_next::protocol::Responder<___T>,
11126    ) -> ::core::result::Result<
11127        (),
11128        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11129    > {
11130        match ordinal {
11131            5728722530628427873 => {
11132                let responder = ::fidl_next::Responder::from_untyped(responder);
11133
11134                match ::fidl_next::DecoderExt::decode(buffer) {
11135                    Ok(decoded) => {
11136                        handler.get_next(decoded, responder).await;
11137                        Ok(())
11138                    }
11139                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11140                        ordinal: 5728722530628427873,
11141                        error,
11142                    }),
11143                }
11144            }
11145
11146            ordinal => handler.on_unknown_interaction(ordinal).await,
11147        }
11148    }
11149}
11150
11151#[derive(PartialEq, Clone, Debug)]
11152pub struct DictionaryEnumerateIteratorGetNextRequest {
11153    pub start_id: u64,
11154
11155    pub limit: u32,
11156}
11157
11158impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest {
11159    type Encoded = WireDictionaryEnumerateIteratorGetNextRequest;
11160}
11161
11162unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextRequest
11163where
11164    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11165{
11166    #[inline]
11167    fn encode(
11168        self,
11169        encoder_: &mut ___E,
11170        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11171    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11172        ::fidl_next::munge! {
11173            let Self::Encoded {
11174                start_id,
11175                limit,
11176
11177            } = out_;
11178        }
11179
11180        ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
11181
11182        ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
11183
11184        Ok(())
11185    }
11186}
11187
11188unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryEnumerateIteratorGetNextRequest
11189where
11190    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11191{
11192    #[inline]
11193    fn encode_ref(
11194        &self,
11195        encoder_: &mut ___E,
11196        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11197    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11198        ::fidl_next::munge! {
11199            let Self::Encoded {
11200
11201                start_id,
11202                limit,
11203
11204            } = out_;
11205        }
11206
11207        ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id)?;
11208
11209        ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit)?;
11210
11211        Ok(())
11212    }
11213}
11214
11215impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextRequest {
11216    type EncodedOption =
11217        ::fidl_next::WireBox<'static, WireDictionaryEnumerateIteratorGetNextRequest>;
11218}
11219
11220unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextRequest
11221where
11222    ___E: ::fidl_next::Encoder + ?Sized,
11223    DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Encode<___E>,
11224{
11225    #[inline]
11226    fn encode_option(
11227        this: ::core::option::Option<Self>,
11228        encoder: &mut ___E,
11229        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11230    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11231        if let Some(inner) = this {
11232            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11233            ::fidl_next::WireBox::encode_present(out);
11234        } else {
11235            ::fidl_next::WireBox::encode_absent(out);
11236        }
11237
11238        Ok(())
11239    }
11240}
11241
11242unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryEnumerateIteratorGetNextRequest
11243where
11244    ___E: ::fidl_next::Encoder + ?Sized,
11245    DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
11246{
11247    #[inline]
11248    fn encode_option_ref(
11249        this: ::core::option::Option<&Self>,
11250        encoder: &mut ___E,
11251        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11252    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11253        if let Some(inner) = this {
11254            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11255            ::fidl_next::WireBox::encode_present(out);
11256        } else {
11257            ::fidl_next::WireBox::encode_absent(out);
11258        }
11259
11260        Ok(())
11261    }
11262}
11263
11264impl ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextRequest>
11265    for DictionaryEnumerateIteratorGetNextRequest
11266{
11267    #[inline]
11268    fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
11269        Self {
11270            start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
11271
11272            limit: ::fidl_next::FromWire::from_wire(wire.limit),
11273        }
11274    }
11275}
11276
11277impl ::fidl_next::IntoNatural for WireDictionaryEnumerateIteratorGetNextRequest {
11278    type Natural = DictionaryEnumerateIteratorGetNextRequest;
11279}
11280
11281impl ::fidl_next::FromWireRef<WireDictionaryEnumerateIteratorGetNextRequest>
11282    for DictionaryEnumerateIteratorGetNextRequest
11283{
11284    #[inline]
11285    fn from_wire_ref(wire: &WireDictionaryEnumerateIteratorGetNextRequest) -> Self {
11286        Self {
11287            start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
11288
11289            limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
11290        }
11291    }
11292}
11293
11294/// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextRequest`].
11295#[derive(Clone, Debug)]
11296#[repr(C)]
11297pub struct WireDictionaryEnumerateIteratorGetNextRequest {
11298    pub start_id: ::fidl_next::WireU64,
11299
11300    pub limit: ::fidl_next::WireU32,
11301}
11302static_assertions::const_assert_eq!(
11303    std::mem::size_of::<WireDictionaryEnumerateIteratorGetNextRequest>(),
11304    16
11305);
11306static_assertions::const_assert_eq!(
11307    std::mem::align_of::<WireDictionaryEnumerateIteratorGetNextRequest>(),
11308    8
11309);
11310
11311static_assertions::const_assert_eq!(
11312    std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextRequest, start_id),
11313    0
11314);
11315
11316static_assertions::const_assert_eq!(
11317    std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextRequest, limit),
11318    8
11319);
11320
11321unsafe impl ::fidl_next::Wire for WireDictionaryEnumerateIteratorGetNextRequest {
11322    type Decoded<'de> = WireDictionaryEnumerateIteratorGetNextRequest;
11323
11324    #[inline]
11325    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11326        ::fidl_next::munge! {
11327            let Self {
11328
11329                start_id,
11330                limit,
11331
11332            } = &mut *out_;
11333        }
11334
11335        ::fidl_next::Wire::zero_padding(start_id);
11336
11337        ::fidl_next::Wire::zero_padding(limit);
11338
11339        unsafe {
11340            out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11341        }
11342    }
11343}
11344
11345unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryEnumerateIteratorGetNextRequest
11346where
11347    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11348{
11349    fn decode(
11350        slot_: ::fidl_next::Slot<'_, Self>,
11351        decoder_: &mut ___D,
11352    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11353        ::fidl_next::munge! {
11354            let Self {
11355
11356                mut start_id,
11357                mut limit,
11358
11359            } = slot_;
11360        }
11361
11362        ::fidl_next::Decode::decode(start_id.as_mut(), decoder_)?;
11363
11364        ::fidl_next::Decode::decode(limit.as_mut(), decoder_)?;
11365
11366        Ok(())
11367    }
11368}
11369
11370#[doc = " A key-value pair in a [`DictionaryRef`], where the value may be elided.\n This is useful for APIs that may wish to omit the value, for example if it could not be\n duplicated.\n"]
11371#[derive(PartialEq, Debug)]
11372pub struct DictionaryOptionalItem {
11373    pub key: ::std::string::String,
11374
11375    pub value: ::core::option::Option<::std::boxed::Box<crate::WrappedCapabilityId>>,
11376}
11377
11378impl ::fidl_next::Encodable for DictionaryOptionalItem {
11379    type Encoded = WireDictionaryOptionalItem<'static>;
11380}
11381
11382unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryOptionalItem
11383where
11384    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11385    ___E: ::fidl_next::Encoder,
11386    ___E: ::fidl_next::fuchsia::HandleEncoder,
11387{
11388    #[inline]
11389    fn encode(
11390        self,
11391        encoder_: &mut ___E,
11392        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11393    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11394        ::fidl_next::munge! {
11395            let Self::Encoded {
11396                key,
11397                value,
11398
11399            } = out_;
11400        }
11401
11402        ::fidl_next::Encode::encode(self.key, encoder_, key)?;
11403
11404        ::fidl_next::Encode::encode(self.value, encoder_, value)?;
11405
11406        Ok(())
11407    }
11408}
11409
11410impl ::fidl_next::EncodableOption for DictionaryOptionalItem {
11411    type EncodedOption = ::fidl_next::WireBox<'static, WireDictionaryOptionalItem<'static>>;
11412}
11413
11414unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryOptionalItem
11415where
11416    ___E: ::fidl_next::Encoder + ?Sized,
11417    DictionaryOptionalItem: ::fidl_next::Encode<___E>,
11418{
11419    #[inline]
11420    fn encode_option(
11421        this: ::core::option::Option<Self>,
11422        encoder: &mut ___E,
11423        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11424    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11425        if let Some(inner) = this {
11426            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11427            ::fidl_next::WireBox::encode_present(out);
11428        } else {
11429            ::fidl_next::WireBox::encode_absent(out);
11430        }
11431
11432        Ok(())
11433    }
11434}
11435
11436impl<'de> ::fidl_next::FromWire<WireDictionaryOptionalItem<'de>> for DictionaryOptionalItem {
11437    #[inline]
11438    fn from_wire(wire: WireDictionaryOptionalItem<'de>) -> Self {
11439        Self {
11440            key: ::fidl_next::FromWire::from_wire(wire.key),
11441
11442            value: ::fidl_next::FromWire::from_wire(wire.value),
11443        }
11444    }
11445}
11446
11447impl<'de> ::fidl_next::IntoNatural for WireDictionaryOptionalItem<'de> {
11448    type Natural = DictionaryOptionalItem;
11449}
11450
11451/// The wire type corresponding to [`DictionaryOptionalItem`].
11452#[derive(Debug)]
11453#[repr(C)]
11454pub struct WireDictionaryOptionalItem<'de> {
11455    pub key: ::fidl_next::WireString<'de>,
11456
11457    pub value: ::fidl_next::WireBox<'de, crate::WireWrappedCapabilityId>,
11458}
11459static_assertions::const_assert_eq!(std::mem::size_of::<WireDictionaryOptionalItem<'_>>(), 24);
11460static_assertions::const_assert_eq!(std::mem::align_of::<WireDictionaryOptionalItem<'_>>(), 8);
11461
11462static_assertions::const_assert_eq!(std::mem::offset_of!(WireDictionaryOptionalItem<'_>, key), 0);
11463
11464static_assertions::const_assert_eq!(
11465    std::mem::offset_of!(WireDictionaryOptionalItem<'_>, value),
11466    16
11467);
11468
11469unsafe impl ::fidl_next::Wire for WireDictionaryOptionalItem<'static> {
11470    type Decoded<'de> = WireDictionaryOptionalItem<'de>;
11471
11472    #[inline]
11473    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11474        ::fidl_next::munge! {
11475            let Self {
11476
11477                key,
11478                value,
11479
11480            } = &mut *out_;
11481        }
11482
11483        ::fidl_next::Wire::zero_padding(key);
11484
11485        ::fidl_next::Wire::zero_padding(value);
11486    }
11487}
11488
11489unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryOptionalItem<'static>
11490where
11491    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11492    ___D: ::fidl_next::Decoder,
11493    ___D: ::fidl_next::fuchsia::HandleDecoder,
11494{
11495    fn decode(
11496        slot_: ::fidl_next::Slot<'_, Self>,
11497        decoder_: &mut ___D,
11498    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11499        ::fidl_next::munge! {
11500            let Self {
11501
11502                mut key,
11503                mut value,
11504
11505            } = slot_;
11506        }
11507
11508        ::fidl_next::Decode::decode(key.as_mut(), decoder_)?;
11509
11510        let key = unsafe { key.deref_unchecked() };
11511
11512        if key.len() > 255 {
11513            return Err(::fidl_next::DecodeError::VectorTooLong {
11514                size: key.len() as u64,
11515                limit: 255,
11516            });
11517        }
11518
11519        ::fidl_next::Decode::decode(value.as_mut(), decoder_)?;
11520
11521        Ok(())
11522    }
11523}
11524
11525#[derive(PartialEq, Debug)]
11526pub struct DictionaryEnumerateIteratorGetNextResponse {
11527    pub items: ::std::vec::Vec<crate::DictionaryOptionalItem>,
11528
11529    pub end_id: u64,
11530}
11531
11532impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse {
11533    type Encoded = WireDictionaryEnumerateIteratorGetNextResponse<'static>;
11534}
11535
11536unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextResponse
11537where
11538    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11539    ___E: ::fidl_next::Encoder,
11540    ___E: ::fidl_next::fuchsia::HandleEncoder,
11541{
11542    #[inline]
11543    fn encode(
11544        self,
11545        encoder_: &mut ___E,
11546        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11547    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11548        ::fidl_next::munge! {
11549            let Self::Encoded {
11550                items,
11551                end_id,
11552
11553            } = out_;
11554        }
11555
11556        ::fidl_next::Encode::encode(self.items, encoder_, items)?;
11557
11558        ::fidl_next::Encode::encode(self.end_id, encoder_, end_id)?;
11559
11560        Ok(())
11561    }
11562}
11563
11564impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextResponse {
11565    type EncodedOption =
11566        ::fidl_next::WireBox<'static, WireDictionaryEnumerateIteratorGetNextResponse<'static>>;
11567}
11568
11569unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextResponse
11570where
11571    ___E: ::fidl_next::Encoder + ?Sized,
11572    DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<___E>,
11573{
11574    #[inline]
11575    fn encode_option(
11576        this: ::core::option::Option<Self>,
11577        encoder: &mut ___E,
11578        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
11579    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11580        if let Some(inner) = this {
11581            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
11582            ::fidl_next::WireBox::encode_present(out);
11583        } else {
11584            ::fidl_next::WireBox::encode_absent(out);
11585        }
11586
11587        Ok(())
11588    }
11589}
11590
11591impl<'de> ::fidl_next::FromWire<WireDictionaryEnumerateIteratorGetNextResponse<'de>>
11592    for DictionaryEnumerateIteratorGetNextResponse
11593{
11594    #[inline]
11595    fn from_wire(wire: WireDictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
11596        Self {
11597            items: ::fidl_next::FromWire::from_wire(wire.items),
11598
11599            end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
11600        }
11601    }
11602}
11603
11604impl<'de> ::fidl_next::IntoNatural for WireDictionaryEnumerateIteratorGetNextResponse<'de> {
11605    type Natural = DictionaryEnumerateIteratorGetNextResponse;
11606}
11607
11608/// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextResponse`].
11609#[derive(Debug)]
11610#[repr(C)]
11611pub struct WireDictionaryEnumerateIteratorGetNextResponse<'de> {
11612    pub items: ::fidl_next::WireVector<'de, crate::WireDictionaryOptionalItem<'de>>,
11613
11614    pub end_id: ::fidl_next::WireU64,
11615}
11616static_assertions::const_assert_eq!(
11617    std::mem::size_of::<WireDictionaryEnumerateIteratorGetNextResponse<'_>>(),
11618    24
11619);
11620static_assertions::const_assert_eq!(
11621    std::mem::align_of::<WireDictionaryEnumerateIteratorGetNextResponse<'_>>(),
11622    8
11623);
11624
11625static_assertions::const_assert_eq!(
11626    std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextResponse<'_>, items),
11627    0
11628);
11629
11630static_assertions::const_assert_eq!(
11631    std::mem::offset_of!(WireDictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
11632    16
11633);
11634
11635unsafe impl ::fidl_next::Wire for WireDictionaryEnumerateIteratorGetNextResponse<'static> {
11636    type Decoded<'de> = WireDictionaryEnumerateIteratorGetNextResponse<'de>;
11637
11638    #[inline]
11639    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11640        ::fidl_next::munge! {
11641            let Self {
11642
11643                items,
11644                end_id,
11645
11646            } = &mut *out_;
11647        }
11648
11649        ::fidl_next::Wire::zero_padding(items);
11650
11651        ::fidl_next::Wire::zero_padding(end_id);
11652    }
11653}
11654
11655unsafe impl<___D> ::fidl_next::Decode<___D>
11656    for WireDictionaryEnumerateIteratorGetNextResponse<'static>
11657where
11658    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11659    ___D: ::fidl_next::Decoder,
11660    ___D: ::fidl_next::fuchsia::HandleDecoder,
11661{
11662    fn decode(
11663        slot_: ::fidl_next::Slot<'_, Self>,
11664        decoder_: &mut ___D,
11665    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11666        ::fidl_next::munge! {
11667            let Self {
11668
11669                mut items,
11670                mut end_id,
11671
11672            } = slot_;
11673        }
11674
11675        ::fidl_next::Decode::decode(items.as_mut(), decoder_)?;
11676
11677        let items = unsafe { items.deref_unchecked() };
11678
11679        if items.len() > 128 {
11680            return Err(::fidl_next::DecodeError::VectorTooLong {
11681                size: items.len() as u64,
11682                limit: 128,
11683            });
11684        }
11685
11686        ::fidl_next::Decode::decode(end_id.as_mut(), decoder_)?;
11687
11688        Ok(())
11689    }
11690}
11691
11692/// The type corresponding to the DictionaryEnumerateIterator protocol.
11693#[derive(PartialEq, Debug)]
11694pub struct DictionaryEnumerateIterator;
11695
11696pub mod dictionary_enumerate_iterator {
11697    pub mod prelude {
11698        pub use crate::{
11699            DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
11700            DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
11701        };
11702
11703        pub use crate::CapabilityStoreError;
11704
11705        pub use crate::DictionaryEnumerateIteratorGetNextRequest;
11706
11707        pub use crate::DictionaryEnumerateIteratorGetNextResponse;
11708    }
11709
11710    pub struct GetNext;
11711
11712    impl ::fidl_next::Method for GetNext {
11713        const ORDINAL: u64 = 1511164556663256527;
11714
11715        type Protocol = crate::DictionaryEnumerateIterator;
11716
11717        type Request = crate::WireDictionaryEnumerateIteratorGetNextRequest;
11718
11719        type Response = ::fidl_next::WireFlexibleResult<
11720            'static,
11721            crate::WireDictionaryEnumerateIteratorGetNextResponse<'static>,
11722            crate::WireCapabilityStoreError,
11723        >;
11724    }
11725
11726    mod ___detail {
11727
11728        pub struct GetNext<T0, T1> {
11729            start_id: T0,
11730
11731            limit: T1,
11732        }
11733
11734        impl<T0, T1> ::fidl_next::Encodable for GetNext<T0, T1>
11735        where
11736            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
11737            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
11738        {
11739            type Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest;
11740        }
11741
11742        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for GetNext<T0, T1>
11743        where
11744            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
11745            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
11746            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
11747        {
11748            #[inline]
11749            fn encode(
11750                self,
11751                encoder_: &mut ___E,
11752                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11753            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11754                ::fidl_next::munge! {
11755                    let Self::Encoded {
11756                        start_id,
11757                        limit,
11758
11759                    } = out_;
11760                }
11761
11762                ::fidl_next::Encode::encode(self.start_id, encoder_, start_id)?;
11763
11764                ::fidl_next::Encode::encode(self.limit, encoder_, limit)?;
11765
11766                Ok(())
11767            }
11768        }
11769
11770        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryEnumerateIterator
11771        where
11772            ___T: ::fidl_next::Transport,
11773        {
11774            type Client = DictionaryEnumerateIteratorClient<___T>;
11775            type Server = DictionaryEnumerateIteratorServer<___T>;
11776        }
11777
11778        /// The client for the `DictionaryEnumerateIterator` protocol.
11779        #[repr(transparent)]
11780        pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
11781            #[allow(dead_code)]
11782            client: ::fidl_next::protocol::Client<___T>,
11783        }
11784
11785        impl<___T> DictionaryEnumerateIteratorClient<___T>
11786        where
11787            ___T: ::fidl_next::Transport,
11788        {
11789            #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
11790            pub fn get_next(
11791                &self,
11792
11793                start_id: impl ::fidl_next::Encode<
11794                    <___T as ::fidl_next::Transport>::SendBuffer,
11795                    Encoded = ::fidl_next::WireU64,
11796                >,
11797
11798                limit: impl ::fidl_next::Encode<
11799                    <___T as ::fidl_next::Transport>::SendBuffer,
11800                    Encoded = ::fidl_next::WireU32,
11801                >,
11802            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11803            where
11804                <___T as ::fidl_next::Transport>::SendBuffer:
11805                    ::fidl_next::encoder::InternalHandleEncoder,
11806            {
11807                self.get_next_with(GetNext { start_id, limit })
11808            }
11809
11810            #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
11811            pub fn get_next_with<___R>(
11812                &self,
11813                request: ___R,
11814            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
11815            where
11816                ___R: ::fidl_next::Encode<
11817                        <___T as ::fidl_next::Transport>::SendBuffer,
11818                        Encoded = crate::WireDictionaryEnumerateIteratorGetNextRequest,
11819                    >,
11820            {
11821                ::fidl_next::TwoWayFuture::from_untyped(
11822                    self.client.send_two_way(1511164556663256527, request),
11823                )
11824            }
11825        }
11826
11827        /// The server for the `DictionaryEnumerateIterator` protocol.
11828        #[repr(transparent)]
11829        pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
11830            server: ::fidl_next::protocol::Server<___T>,
11831        }
11832
11833        impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
11834    }
11835}
11836
11837/// A client handler for the DictionaryEnumerateIterator protocol.
11838///
11839/// See [`DictionaryEnumerateIterator`] for more details.
11840pub trait DictionaryEnumerateIteratorClientHandler<
11841    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11842    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11843>
11844{
11845    fn on_unknown_interaction(
11846        &mut self,
11847        ordinal: u64,
11848    ) -> impl ::core::future::Future<
11849        Output = ::core::result::Result<
11850            (),
11851            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11852        >,
11853    > + ::core::marker::Send {
11854        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11855    }
11856}
11857
11858impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
11859where
11860    ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
11861    ___T: ::fidl_next::Transport,
11862    <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Response:
11863        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11864{
11865    async fn on_event(
11866        handler: &mut ___H,
11867        ordinal: u64,
11868        buffer: ___T::RecvBuffer,
11869    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11870        match ordinal {
11871            ordinal => handler.on_unknown_interaction(ordinal).await,
11872        }
11873    }
11874}
11875
11876/// A server handler for the DictionaryEnumerateIterator protocol.
11877///
11878/// See [`DictionaryEnumerateIterator`] for more details.
11879pub trait DictionaryEnumerateIteratorServerHandler<
11880    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
11881    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11882>
11883{
11884    #[doc = " Returns the next batch of results for a [Dictionary.Enumerate] call, returning up to\n `limit` results. `limit` can be at most [MAX_DICTIONARY_ITERATOR_CHUNK].\n\n The value of each of `items` is a duplicate of the original capability\n ([CapabilityStore.Duplicate]), unless it could not be duplicated, it which case it will\n be null.\n\n Each returned capability will be assigned a monotonically increasing [CapabilityId] starting\n from `start_id`.\n\n In addition to the `items`, returns `end_id`, which is one more than the highest id reserved\n by [GetNext]. `end_id` can be used as the `start_id` for the next call to [GetNext].\n\n If [GetNext] returns an error, the server will also close the channel.\n\n Errors:\n\n - `ID_ALREADY_EXISTS` if some id in the range `[start_id, limit)` already exists in this\n   store.\n - `INVALID_ARGS` if `limit` was `0` or greater than `MAX_DICTIONARY_ITERATOR_CHUNK`.\n"]
11885    fn get_next(
11886        &mut self,
11887
11888        request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
11889
11890        responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
11891    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11892
11893    fn on_unknown_interaction(
11894        &mut self,
11895        ordinal: u64,
11896    ) -> impl ::core::future::Future<
11897        Output = ::core::result::Result<
11898            (),
11899            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11900        >,
11901    > + ::core::marker::Send {
11902        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
11903    }
11904}
11905
11906impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
11907where
11908    ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
11909    ___T: ::fidl_next::Transport,
11910    <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
11911        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
11912{
11913    async fn on_one_way(
11914        handler: &mut ___H,
11915        ordinal: u64,
11916        buffer: ___T::RecvBuffer,
11917    ) -> ::core::result::Result<
11918        (),
11919        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11920    > {
11921        match ordinal {
11922            ordinal => handler.on_unknown_interaction(ordinal).await,
11923        }
11924    }
11925
11926    async fn on_two_way(
11927        handler: &mut ___H,
11928        ordinal: u64,
11929        buffer: ___T::RecvBuffer,
11930        responder: ::fidl_next::protocol::Responder<___T>,
11931    ) -> ::core::result::Result<
11932        (),
11933        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11934    > {
11935        match ordinal {
11936            1511164556663256527 => {
11937                let responder = ::fidl_next::Responder::from_untyped(responder);
11938
11939                match ::fidl_next::DecoderExt::decode(buffer) {
11940                    Ok(decoded) => {
11941                        handler.get_next(decoded, responder).await;
11942                        Ok(())
11943                    }
11944                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11945                        ordinal: 1511164556663256527,
11946                        error,
11947                    }),
11948                }
11949            }
11950
11951            ordinal => handler.on_unknown_interaction(ordinal).await,
11952        }
11953    }
11954}
11955
11956#[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
11957#[derive(Clone, Copy, Debug, PartialEq, Eq)]
11958#[repr(u32)]
11959pub enum DictionaryError {
11960    NotFound = 1,
11961    AlreadyExists = 2,
11962    BadCapability = 3,
11963    InvalidKey = 4,
11964    NotCloneable = 5,
11965    UnknownOrdinal_(u32) = 6,
11966}
11967
11968impl ::fidl_next::Encodable for DictionaryError {
11969    type Encoded = WireDictionaryError;
11970}
11971impl ::std::convert::From<u32> for DictionaryError {
11972    fn from(value: u32) -> Self {
11973        match value {
11974            1 => Self::NotFound,
11975            2 => Self::AlreadyExists,
11976            3 => Self::BadCapability,
11977            4 => Self::InvalidKey,
11978            5 => Self::NotCloneable,
11979
11980            _ => Self::UnknownOrdinal_(value),
11981        }
11982    }
11983}
11984
11985unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryError
11986where
11987    ___E: ?Sized,
11988{
11989    #[inline]
11990    fn encode(
11991        self,
11992        encoder: &mut ___E,
11993        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
11994    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
11995        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
11996    }
11997}
11998
11999unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryError
12000where
12001    ___E: ?Sized,
12002{
12003    #[inline]
12004    fn encode_ref(
12005        &self,
12006        encoder: &mut ___E,
12007        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12008    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12009        ::fidl_next::munge!(let WireDictionaryError { value } = out);
12010        let _ = value.write(::fidl_next::WireU32::from(match *self {
12011            Self::NotFound => 1,
12012
12013            Self::AlreadyExists => 2,
12014
12015            Self::BadCapability => 3,
12016
12017            Self::InvalidKey => 4,
12018
12019            Self::NotCloneable => 5,
12020
12021            Self::UnknownOrdinal_(value) => value,
12022        }));
12023
12024        Ok(())
12025    }
12026}
12027
12028impl ::core::convert::From<WireDictionaryError> for DictionaryError {
12029    fn from(wire: WireDictionaryError) -> Self {
12030        match u32::from(wire.value) {
12031            1 => Self::NotFound,
12032
12033            2 => Self::AlreadyExists,
12034
12035            3 => Self::BadCapability,
12036
12037            4 => Self::InvalidKey,
12038
12039            5 => Self::NotCloneable,
12040
12041            value => Self::UnknownOrdinal_(value),
12042        }
12043    }
12044}
12045
12046impl ::fidl_next::FromWire<WireDictionaryError> for DictionaryError {
12047    #[inline]
12048    fn from_wire(wire: WireDictionaryError) -> Self {
12049        Self::from(wire)
12050    }
12051}
12052
12053impl ::fidl_next::IntoNatural for WireDictionaryError {
12054    type Natural = DictionaryError;
12055}
12056
12057impl ::fidl_next::FromWireRef<WireDictionaryError> for DictionaryError {
12058    #[inline]
12059    fn from_wire_ref(wire: &WireDictionaryError) -> Self {
12060        Self::from(*wire)
12061    }
12062}
12063
12064/// The wire type corresponding to [`DictionaryError`].
12065#[derive(Clone, Copy, Debug, PartialEq, Eq)]
12066#[repr(transparent)]
12067pub struct WireDictionaryError {
12068    value: ::fidl_next::WireU32,
12069}
12070
12071unsafe impl ::fidl_next::Wire for WireDictionaryError {
12072    type Decoded<'de> = Self;
12073
12074    #[inline]
12075    fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12076        // Wire enums have no padding
12077    }
12078}
12079
12080impl WireDictionaryError {
12081    pub const NOT_FOUND: WireDictionaryError =
12082        WireDictionaryError { value: ::fidl_next::WireU32(1) };
12083
12084    pub const ALREADY_EXISTS: WireDictionaryError =
12085        WireDictionaryError { value: ::fidl_next::WireU32(2) };
12086
12087    pub const BAD_CAPABILITY: WireDictionaryError =
12088        WireDictionaryError { value: ::fidl_next::WireU32(3) };
12089
12090    pub const INVALID_KEY: WireDictionaryError =
12091        WireDictionaryError { value: ::fidl_next::WireU32(4) };
12092
12093    pub const NOT_CLONEABLE: WireDictionaryError =
12094        WireDictionaryError { value: ::fidl_next::WireU32(5) };
12095}
12096
12097unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryError
12098where
12099    ___D: ?Sized,
12100{
12101    fn decode(
12102        slot: ::fidl_next::Slot<'_, Self>,
12103        _: &mut ___D,
12104    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12105        Ok(())
12106    }
12107}
12108
12109impl ::core::convert::From<DictionaryError> for WireDictionaryError {
12110    fn from(natural: DictionaryError) -> Self {
12111        match natural {
12112            DictionaryError::NotFound => WireDictionaryError::NOT_FOUND,
12113
12114            DictionaryError::AlreadyExists => WireDictionaryError::ALREADY_EXISTS,
12115
12116            DictionaryError::BadCapability => WireDictionaryError::BAD_CAPABILITY,
12117
12118            DictionaryError::InvalidKey => WireDictionaryError::INVALID_KEY,
12119
12120            DictionaryError::NotCloneable => WireDictionaryError::NOT_CLONEABLE,
12121
12122            DictionaryError::UnknownOrdinal_(value) => {
12123                WireDictionaryError { value: ::fidl_next::WireU32::from(value) }
12124            }
12125        }
12126    }
12127}
12128
12129#[derive(PartialEq, Debug)]
12130pub struct DictionaryKeysIteratorGetNextResponse {
12131    pub keys: ::std::vec::Vec<::std::string::String>,
12132}
12133
12134impl ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse {
12135    type Encoded = WireDictionaryKeysIteratorGetNextResponse<'static>;
12136}
12137
12138unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse
12139where
12140    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12141    ___E: ::fidl_next::Encoder,
12142    ___E: ::fidl_next::fuchsia::HandleEncoder,
12143{
12144    #[inline]
12145    fn encode(
12146        self,
12147        encoder_: &mut ___E,
12148        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12149    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12150        ::fidl_next::munge! {
12151            let Self::Encoded {
12152                keys,
12153
12154            } = out_;
12155        }
12156
12157        ::fidl_next::Encode::encode(self.keys, encoder_, keys)?;
12158
12159        Ok(())
12160    }
12161}
12162
12163impl ::fidl_next::EncodableOption for DictionaryKeysIteratorGetNextResponse {
12164    type EncodedOption =
12165        ::fidl_next::WireBox<'static, WireDictionaryKeysIteratorGetNextResponse<'static>>;
12166}
12167
12168unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryKeysIteratorGetNextResponse
12169where
12170    ___E: ::fidl_next::Encoder + ?Sized,
12171    DictionaryKeysIteratorGetNextResponse: ::fidl_next::Encode<___E>,
12172{
12173    #[inline]
12174    fn encode_option(
12175        this: ::core::option::Option<Self>,
12176        encoder: &mut ___E,
12177        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12178    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12179        if let Some(inner) = this {
12180            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
12181            ::fidl_next::WireBox::encode_present(out);
12182        } else {
12183            ::fidl_next::WireBox::encode_absent(out);
12184        }
12185
12186        Ok(())
12187    }
12188}
12189
12190impl<'de> ::fidl_next::FromWire<WireDictionaryKeysIteratorGetNextResponse<'de>>
12191    for DictionaryKeysIteratorGetNextResponse
12192{
12193    #[inline]
12194    fn from_wire(wire: WireDictionaryKeysIteratorGetNextResponse<'de>) -> Self {
12195        Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
12196    }
12197}
12198
12199impl<'de> ::fidl_next::IntoNatural for WireDictionaryKeysIteratorGetNextResponse<'de> {
12200    type Natural = DictionaryKeysIteratorGetNextResponse;
12201}
12202
12203/// The wire type corresponding to [`DictionaryKeysIteratorGetNextResponse`].
12204#[derive(Debug)]
12205#[repr(C)]
12206pub struct WireDictionaryKeysIteratorGetNextResponse<'de> {
12207    pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
12208}
12209static_assertions::const_assert_eq!(
12210    std::mem::size_of::<WireDictionaryKeysIteratorGetNextResponse<'_>>(),
12211    16
12212);
12213static_assertions::const_assert_eq!(
12214    std::mem::align_of::<WireDictionaryKeysIteratorGetNextResponse<'_>>(),
12215    8
12216);
12217
12218static_assertions::const_assert_eq!(
12219    std::mem::offset_of!(WireDictionaryKeysIteratorGetNextResponse<'_>, keys),
12220    0
12221);
12222
12223unsafe impl ::fidl_next::Wire for WireDictionaryKeysIteratorGetNextResponse<'static> {
12224    type Decoded<'de> = WireDictionaryKeysIteratorGetNextResponse<'de>;
12225
12226    #[inline]
12227    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12228        ::fidl_next::munge! {
12229            let Self {
12230
12231                keys,
12232
12233            } = &mut *out_;
12234        }
12235
12236        ::fidl_next::Wire::zero_padding(keys);
12237    }
12238}
12239
12240unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryKeysIteratorGetNextResponse<'static>
12241where
12242    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12243    ___D: ::fidl_next::Decoder,
12244    ___D: ::fidl_next::fuchsia::HandleDecoder,
12245{
12246    fn decode(
12247        slot_: ::fidl_next::Slot<'_, Self>,
12248        decoder_: &mut ___D,
12249    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12250        ::fidl_next::munge! {
12251            let Self {
12252
12253                mut keys,
12254
12255            } = slot_;
12256        }
12257
12258        ::fidl_next::Decode::decode(keys.as_mut(), decoder_)?;
12259
12260        let keys = unsafe { keys.deref_unchecked() };
12261
12262        if keys.len() > 128 {
12263            return Err(::fidl_next::DecodeError::VectorTooLong {
12264                size: keys.len() as u64,
12265                limit: 128,
12266            });
12267        }
12268
12269        Ok(())
12270    }
12271}
12272
12273/// The type corresponding to the DictionaryKeysIterator protocol.
12274#[derive(PartialEq, Debug)]
12275pub struct DictionaryKeysIterator;
12276
12277pub mod dictionary_keys_iterator {
12278    pub mod prelude {
12279        pub use crate::{
12280            DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
12281            DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
12282        };
12283
12284        pub use crate::DictionaryKeysIteratorGetNextResponse;
12285    }
12286
12287    pub struct GetNext;
12288
12289    impl ::fidl_next::Method for GetNext {
12290        const ORDINAL: u64 = 4987781442555247955;
12291
12292        type Protocol = crate::DictionaryKeysIterator;
12293
12294        type Request = ();
12295
12296        type Response = ::fidl_next::WireFlexible<
12297            'static,
12298            crate::WireDictionaryKeysIteratorGetNextResponse<'static>,
12299        >;
12300    }
12301
12302    mod ___detail {
12303
12304        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryKeysIterator
12305        where
12306            ___T: ::fidl_next::Transport,
12307        {
12308            type Client = DictionaryKeysIteratorClient<___T>;
12309            type Server = DictionaryKeysIteratorServer<___T>;
12310        }
12311
12312        /// The client for the `DictionaryKeysIterator` protocol.
12313        #[repr(transparent)]
12314        pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
12315            #[allow(dead_code)]
12316            client: ::fidl_next::protocol::Client<___T>,
12317        }
12318
12319        impl<___T> DictionaryKeysIteratorClient<___T>
12320        where
12321            ___T: ::fidl_next::Transport,
12322        {
12323            pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
12324                ::fidl_next::TwoWayFuture::from_untyped(
12325                    self.client.send_two_way(4987781442555247955, ()),
12326                )
12327            }
12328        }
12329
12330        /// The server for the `DictionaryKeysIterator` protocol.
12331        #[repr(transparent)]
12332        pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
12333            server: ::fidl_next::protocol::Server<___T>,
12334        }
12335
12336        impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
12337    }
12338}
12339
12340/// A client handler for the DictionaryKeysIterator protocol.
12341///
12342/// See [`DictionaryKeysIterator`] for more details.
12343pub trait DictionaryKeysIteratorClientHandler<
12344    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12345    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12346>
12347{
12348    fn on_unknown_interaction(
12349        &mut self,
12350        ordinal: u64,
12351    ) -> impl ::core::future::Future<
12352        Output = ::core::result::Result<
12353            (),
12354            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12355        >,
12356    > + ::core::marker::Send {
12357        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12358    }
12359}
12360
12361impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
12362where
12363    ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
12364    ___T: ::fidl_next::Transport,
12365    <dictionary_keys_iterator::GetNext as ::fidl_next::Method>::Response:
12366        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12367{
12368    async fn on_event(
12369        handler: &mut ___H,
12370        ordinal: u64,
12371        buffer: ___T::RecvBuffer,
12372    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12373        match ordinal {
12374            ordinal => handler.on_unknown_interaction(ordinal).await,
12375        }
12376    }
12377}
12378
12379/// A server handler for the DictionaryKeysIterator protocol.
12380///
12381/// See [`DictionaryKeysIterator`] for more details.
12382pub trait DictionaryKeysIteratorServerHandler<
12383    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12384    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12385>
12386{
12387    fn get_next(
12388        &mut self,
12389
12390        responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
12391    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12392
12393    fn on_unknown_interaction(
12394        &mut self,
12395        ordinal: u64,
12396    ) -> impl ::core::future::Future<
12397        Output = ::core::result::Result<
12398            (),
12399            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12400        >,
12401    > + ::core::marker::Send {
12402        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12403    }
12404}
12405
12406impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
12407where
12408    ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
12409    ___T: ::fidl_next::Transport,
12410{
12411    async fn on_one_way(
12412        handler: &mut ___H,
12413        ordinal: u64,
12414        buffer: ___T::RecvBuffer,
12415    ) -> ::core::result::Result<
12416        (),
12417        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12418    > {
12419        match ordinal {
12420            ordinal => handler.on_unknown_interaction(ordinal).await,
12421        }
12422    }
12423
12424    async fn on_two_way(
12425        handler: &mut ___H,
12426        ordinal: u64,
12427        buffer: ___T::RecvBuffer,
12428        responder: ::fidl_next::protocol::Responder<___T>,
12429    ) -> ::core::result::Result<
12430        (),
12431        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12432    > {
12433        match ordinal {
12434            4987781442555247955 => {
12435                let responder = ::fidl_next::Responder::from_untyped(responder);
12436
12437                handler.get_next(responder).await;
12438                Ok(())
12439            }
12440
12441            ordinal => handler.on_unknown_interaction(ordinal).await,
12442        }
12443    }
12444}
12445
12446#[derive(PartialEq, Debug)]
12447pub enum DictionaryRouterRouteResponse {
12448    Dictionary(crate::DictionaryRef),
12449
12450    Unavailable(crate::Unit),
12451}
12452
12453impl ::fidl_next::Encodable for DictionaryRouterRouteResponse {
12454    type Encoded = WireDictionaryRouterRouteResponse;
12455}
12456
12457unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRouterRouteResponse
12458where
12459    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12460    ___E: ::fidl_next::fuchsia::HandleEncoder,
12461{
12462    #[inline]
12463    fn encode(
12464        self,
12465        encoder: &mut ___E,
12466        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12467    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12468        ::fidl_next::munge!(let WireDictionaryRouterRouteResponse { raw, _phantom: _ } = out);
12469
12470        match self {
12471            Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12472                ___E,
12473                crate::DictionaryRef,
12474            >(value, 1, encoder, raw)?,
12475
12476            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12477                ___E,
12478                crate::Unit,
12479            >(value, 2, encoder, raw)?,
12480        }
12481
12482        Ok(())
12483    }
12484}
12485
12486impl ::fidl_next::EncodableOption for DictionaryRouterRouteResponse {
12487    type EncodedOption = WireOptionalDictionaryRouterRouteResponse;
12488}
12489
12490unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRouterRouteResponse
12491where
12492    ___E: ?Sized,
12493    DictionaryRouterRouteResponse: ::fidl_next::Encode<___E>,
12494{
12495    #[inline]
12496    fn encode_option(
12497        this: ::core::option::Option<Self>,
12498        encoder: &mut ___E,
12499        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12500    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12501        ::fidl_next::munge!(let WireOptionalDictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
12502
12503        if let Some(inner) = this {
12504            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
12505            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
12506        } else {
12507            ::fidl_next::RawWireUnion::encode_absent(raw);
12508        }
12509
12510        Ok(())
12511    }
12512}
12513
12514impl ::fidl_next::FromWire<WireDictionaryRouterRouteResponse> for DictionaryRouterRouteResponse {
12515    #[inline]
12516    fn from_wire(wire: WireDictionaryRouterRouteResponse) -> Self {
12517        let wire = ::core::mem::ManuallyDrop::new(wire);
12518        match wire.raw.ordinal() {
12519            1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
12520                wire.raw.get().read_unchecked::<crate::WireDictionaryRef>()
12521            })),
12522
12523            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
12524                wire.raw.get().read_unchecked::<crate::WireUnit>()
12525            })),
12526
12527            _ => unsafe { ::core::hint::unreachable_unchecked() },
12528        }
12529    }
12530}
12531
12532impl ::fidl_next::IntoNatural for WireDictionaryRouterRouteResponse {
12533    type Natural = DictionaryRouterRouteResponse;
12534}
12535
12536impl ::fidl_next::FromWireOption<WireOptionalDictionaryRouterRouteResponse>
12537    for DictionaryRouterRouteResponse
12538{
12539    #[inline]
12540    fn from_wire_option(
12541        wire: WireOptionalDictionaryRouterRouteResponse,
12542    ) -> ::core::option::Option<Self> {
12543        if let Some(inner) = wire.into_option() {
12544            Some(::fidl_next::FromWire::from_wire(inner))
12545        } else {
12546            None
12547        }
12548    }
12549}
12550
12551impl ::fidl_next::IntoNatural for WireOptionalDictionaryRouterRouteResponse {
12552    type Natural = ::core::option::Option<DictionaryRouterRouteResponse>;
12553}
12554
12555impl ::fidl_next::FromWireOption<WireOptionalDictionaryRouterRouteResponse>
12556    for Box<DictionaryRouterRouteResponse>
12557{
12558    #[inline]
12559    fn from_wire_option(
12560        wire: WireOptionalDictionaryRouterRouteResponse,
12561    ) -> ::core::option::Option<Self> {
12562        <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
12563            WireOptionalDictionaryRouterRouteResponse,
12564        >>::from_wire_option(wire)
12565        .map(Box::new)
12566    }
12567}
12568
12569/// The wire type corresponding to [`DictionaryRouterRouteResponse`].
12570#[repr(transparent)]
12571pub struct WireDictionaryRouterRouteResponse {
12572    raw: ::fidl_next::RawWireUnion,
12573    _phantom: ::core::marker::PhantomData<()>,
12574}
12575
12576impl Drop for WireDictionaryRouterRouteResponse {
12577    fn drop(&mut self) {
12578        match self.raw.ordinal() {
12579            1 => {
12580                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDictionaryRef>() };
12581            }
12582
12583            2 => {
12584                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
12585            }
12586
12587            _ => unsafe { ::core::hint::unreachable_unchecked() },
12588        }
12589    }
12590}
12591
12592unsafe impl ::fidl_next::Wire for WireDictionaryRouterRouteResponse {
12593    type Decoded<'de> = WireDictionaryRouterRouteResponse;
12594
12595    #[inline]
12596    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12597        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12598        ::fidl_next::RawWireUnion::zero_padding(raw);
12599    }
12600}
12601
12602pub mod dictionary_router_route_response {
12603    pub enum Ref<'de> {
12604        Dictionary(&'de crate::WireDictionaryRef),
12605
12606        Unavailable(&'de crate::WireUnit),
12607    }
12608}
12609
12610impl WireDictionaryRouterRouteResponse {
12611    pub fn as_ref(&self) -> crate::dictionary_router_route_response::Ref<'_> {
12612        match self.raw.ordinal() {
12613            1 => crate::dictionary_router_route_response::Ref::Dictionary(unsafe {
12614                self.raw.get().deref_unchecked::<crate::WireDictionaryRef>()
12615            }),
12616
12617            2 => crate::dictionary_router_route_response::Ref::Unavailable(unsafe {
12618                self.raw.get().deref_unchecked::<crate::WireUnit>()
12619            }),
12620
12621            _ => unsafe { ::core::hint::unreachable_unchecked() },
12622        }
12623    }
12624}
12625
12626unsafe impl<___D> ::fidl_next::Decode<___D> for WireDictionaryRouterRouteResponse
12627where
12628    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12629    ___D: ::fidl_next::fuchsia::HandleDecoder,
12630{
12631    fn decode(
12632        mut slot: ::fidl_next::Slot<'_, Self>,
12633        decoder: &mut ___D,
12634    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12635        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12636        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12637            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDictionaryRef>(
12638                raw, decoder,
12639            )?,
12640
12641            2 => {
12642                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
12643            }
12644
12645            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12646        }
12647
12648        Ok(())
12649    }
12650}
12651
12652impl ::core::fmt::Debug for WireDictionaryRouterRouteResponse {
12653    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12654        match self.raw.ordinal() {
12655            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDictionaryRef>().fmt(f) },
12656            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
12657            _ => unsafe { ::core::hint::unreachable_unchecked() },
12658        }
12659    }
12660}
12661
12662#[repr(transparent)]
12663pub struct WireOptionalDictionaryRouterRouteResponse {
12664    raw: ::fidl_next::RawWireUnion,
12665    _phantom: ::core::marker::PhantomData<()>,
12666}
12667
12668unsafe impl ::fidl_next::Wire for WireOptionalDictionaryRouterRouteResponse {
12669    type Decoded<'de> = WireOptionalDictionaryRouterRouteResponse;
12670
12671    #[inline]
12672    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12673        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12674        ::fidl_next::RawWireUnion::zero_padding(raw);
12675    }
12676}
12677
12678impl WireOptionalDictionaryRouterRouteResponse {
12679    pub fn is_some(&self) -> bool {
12680        self.raw.is_some()
12681    }
12682
12683    pub fn is_none(&self) -> bool {
12684        self.raw.is_none()
12685    }
12686
12687    pub fn as_ref(&self) -> ::core::option::Option<&WireDictionaryRouterRouteResponse> {
12688        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
12689    }
12690
12691    pub fn into_option(self) -> ::core::option::Option<WireDictionaryRouterRouteResponse> {
12692        if self.is_some() {
12693            Some(WireDictionaryRouterRouteResponse {
12694                raw: self.raw,
12695                _phantom: ::core::marker::PhantomData,
12696            })
12697        } else {
12698            None
12699        }
12700    }
12701}
12702
12703unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDictionaryRouterRouteResponse
12704where
12705    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12706    ___D: ::fidl_next::fuchsia::HandleDecoder,
12707{
12708    fn decode(
12709        mut slot: ::fidl_next::Slot<'_, Self>,
12710        decoder: &mut ___D,
12711    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12712        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12713        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12714            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDictionaryRef>(
12715                raw, decoder,
12716            )?,
12717
12718            2 => {
12719                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
12720            }
12721
12722            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
12723            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
12724        }
12725
12726        Ok(())
12727    }
12728}
12729
12730impl ::core::fmt::Debug for WireOptionalDictionaryRouterRouteResponse {
12731    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12732        self.as_ref().fmt(f)
12733    }
12734}
12735
12736/// The type corresponding to the DictionaryRouter protocol.
12737#[derive(PartialEq, Debug)]
12738pub struct DictionaryRouter;
12739
12740impl ::fidl_next::Discoverable for DictionaryRouter {
12741    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
12742}
12743
12744pub mod dictionary_router {
12745    pub mod prelude {
12746        pub use crate::{
12747            DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
12748            dictionary_router,
12749        };
12750
12751        pub use crate::DictionaryRouterRouteResponse;
12752
12753        pub use crate::RouteRequest;
12754
12755        pub use crate::RouterError;
12756    }
12757
12758    pub struct Route;
12759
12760    impl ::fidl_next::Method for Route {
12761        const ORDINAL: u64 = 8164012099375978399;
12762
12763        type Protocol = crate::DictionaryRouter;
12764
12765        type Request = crate::WireRouteRequest<'static>;
12766
12767        type Response = ::fidl_next::WireFlexibleResult<
12768            'static,
12769            crate::WireDictionaryRouterRouteResponse,
12770            crate::WireRouterError,
12771        >;
12772    }
12773
12774    mod ___detail {
12775
12776        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DictionaryRouter
12777        where
12778            ___T: ::fidl_next::Transport,
12779        {
12780            type Client = DictionaryRouterClient<___T>;
12781            type Server = DictionaryRouterServer<___T>;
12782        }
12783
12784        /// The client for the `DictionaryRouter` protocol.
12785        #[repr(transparent)]
12786        pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
12787            #[allow(dead_code)]
12788            client: ::fidl_next::protocol::Client<___T>,
12789        }
12790
12791        impl<___T> DictionaryRouterClient<___T>
12792        where
12793            ___T: ::fidl_next::Transport,
12794        {
12795            pub fn route_with<___R>(
12796                &self,
12797                request: ___R,
12798            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
12799            where
12800                ___R: ::fidl_next::Encode<
12801                        <___T as ::fidl_next::Transport>::SendBuffer,
12802                        Encoded = crate::WireRouteRequest<'static>,
12803                    >,
12804            {
12805                ::fidl_next::TwoWayFuture::from_untyped(
12806                    self.client.send_two_way(8164012099375978399, request),
12807                )
12808            }
12809        }
12810
12811        /// The server for the `DictionaryRouter` protocol.
12812        #[repr(transparent)]
12813        pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
12814            server: ::fidl_next::protocol::Server<___T>,
12815        }
12816
12817        impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
12818    }
12819}
12820
12821/// A client handler for the DictionaryRouter protocol.
12822///
12823/// See [`DictionaryRouter`] for more details.
12824pub trait DictionaryRouterClientHandler<
12825    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12826    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12827>
12828{
12829    fn on_unknown_interaction(
12830        &mut self,
12831        ordinal: u64,
12832    ) -> impl ::core::future::Future<
12833        Output = ::core::result::Result<
12834            (),
12835            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12836        >,
12837    > + ::core::marker::Send {
12838        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12839    }
12840}
12841
12842impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
12843where
12844    ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
12845    ___T: ::fidl_next::Transport,
12846    <dictionary_router::Route as ::fidl_next::Method>::Response:
12847        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12848{
12849    async fn on_event(
12850        handler: &mut ___H,
12851        ordinal: u64,
12852        buffer: ___T::RecvBuffer,
12853    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12854        match ordinal {
12855            ordinal => handler.on_unknown_interaction(ordinal).await,
12856        }
12857    }
12858}
12859
12860/// A server handler for the DictionaryRouter protocol.
12861///
12862/// See [`DictionaryRouter`] for more details.
12863pub trait DictionaryRouterServerHandler<
12864    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
12865    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12866>
12867{
12868    fn route(
12869        &mut self,
12870
12871        request: ::fidl_next::Request<dictionary_router::Route, ___T>,
12872
12873        responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
12874    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12875
12876    fn on_unknown_interaction(
12877        &mut self,
12878        ordinal: u64,
12879    ) -> impl ::core::future::Future<
12880        Output = ::core::result::Result<
12881            (),
12882            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12883        >,
12884    > + ::core::marker::Send {
12885        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
12886    }
12887}
12888
12889impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
12890where
12891    ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
12892    ___T: ::fidl_next::Transport,
12893    <dictionary_router::Route as ::fidl_next::Method>::Request:
12894        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
12895{
12896    async fn on_one_way(
12897        handler: &mut ___H,
12898        ordinal: u64,
12899        buffer: ___T::RecvBuffer,
12900    ) -> ::core::result::Result<
12901        (),
12902        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12903    > {
12904        match ordinal {
12905            ordinal => handler.on_unknown_interaction(ordinal).await,
12906        }
12907    }
12908
12909    async fn on_two_way(
12910        handler: &mut ___H,
12911        ordinal: u64,
12912        buffer: ___T::RecvBuffer,
12913        responder: ::fidl_next::protocol::Responder<___T>,
12914    ) -> ::core::result::Result<
12915        (),
12916        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12917    > {
12918        match ordinal {
12919            8164012099375978399 => {
12920                let responder = ::fidl_next::Responder::from_untyped(responder);
12921
12922                match ::fidl_next::DecoderExt::decode(buffer) {
12923                    Ok(decoded) => {
12924                        handler.route(decoded, responder).await;
12925                        Ok(())
12926                    }
12927                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12928                        ordinal: 8164012099375978399,
12929                        error,
12930                    }),
12931                }
12932            }
12933
12934            ordinal => handler.on_unknown_interaction(ordinal).await,
12935        }
12936    }
12937}
12938
12939#[derive(PartialEq, Debug)]
12940pub enum DirConnectorRouterRouteResponse {
12941    DirConnector(crate::DirConnector),
12942
12943    Unavailable(crate::Unit),
12944}
12945
12946impl ::fidl_next::Encodable for DirConnectorRouterRouteResponse {
12947    type Encoded = WireDirConnectorRouterRouteResponse;
12948}
12949
12950unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnectorRouterRouteResponse
12951where
12952    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
12953    ___E: ::fidl_next::fuchsia::HandleEncoder,
12954{
12955    #[inline]
12956    fn encode(
12957        self,
12958        encoder: &mut ___E,
12959        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
12960    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12961        ::fidl_next::munge!(let WireDirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
12962
12963        match self {
12964            Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12965                ___E,
12966                crate::DirConnector,
12967            >(value, 1, encoder, raw)?,
12968
12969            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
12970                ___E,
12971                crate::Unit,
12972            >(value, 2, encoder, raw)?,
12973        }
12974
12975        Ok(())
12976    }
12977}
12978
12979impl ::fidl_next::EncodableOption for DirConnectorRouterRouteResponse {
12980    type EncodedOption = WireOptionalDirConnectorRouterRouteResponse;
12981}
12982
12983unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnectorRouterRouteResponse
12984where
12985    ___E: ?Sized,
12986    DirConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
12987{
12988    #[inline]
12989    fn encode_option(
12990        this: ::core::option::Option<Self>,
12991        encoder: &mut ___E,
12992        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
12993    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
12994        ::fidl_next::munge!(let WireOptionalDirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
12995
12996        if let Some(inner) = this {
12997            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
12998            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
12999        } else {
13000            ::fidl_next::RawWireUnion::encode_absent(raw);
13001        }
13002
13003        Ok(())
13004    }
13005}
13006
13007impl ::fidl_next::FromWire<WireDirConnectorRouterRouteResponse>
13008    for DirConnectorRouterRouteResponse
13009{
13010    #[inline]
13011    fn from_wire(wire: WireDirConnectorRouterRouteResponse) -> Self {
13012        let wire = ::core::mem::ManuallyDrop::new(wire);
13013        match wire.raw.ordinal() {
13014            1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
13015                wire.raw.get().read_unchecked::<crate::WireDirConnector>()
13016            })),
13017
13018            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
13019                wire.raw.get().read_unchecked::<crate::WireUnit>()
13020            })),
13021
13022            _ => unsafe { ::core::hint::unreachable_unchecked() },
13023        }
13024    }
13025}
13026
13027impl ::fidl_next::IntoNatural for WireDirConnectorRouterRouteResponse {
13028    type Natural = DirConnectorRouterRouteResponse;
13029}
13030
13031impl ::fidl_next::FromWireOption<WireOptionalDirConnectorRouterRouteResponse>
13032    for DirConnectorRouterRouteResponse
13033{
13034    #[inline]
13035    fn from_wire_option(
13036        wire: WireOptionalDirConnectorRouterRouteResponse,
13037    ) -> ::core::option::Option<Self> {
13038        if let Some(inner) = wire.into_option() {
13039            Some(::fidl_next::FromWire::from_wire(inner))
13040        } else {
13041            None
13042        }
13043    }
13044}
13045
13046impl ::fidl_next::IntoNatural for WireOptionalDirConnectorRouterRouteResponse {
13047    type Natural = ::core::option::Option<DirConnectorRouterRouteResponse>;
13048}
13049
13050impl ::fidl_next::FromWireOption<WireOptionalDirConnectorRouterRouteResponse>
13051    for Box<DirConnectorRouterRouteResponse>
13052{
13053    #[inline]
13054    fn from_wire_option(
13055        wire: WireOptionalDirConnectorRouterRouteResponse,
13056    ) -> ::core::option::Option<Self> {
13057        <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
13058            WireOptionalDirConnectorRouterRouteResponse,
13059        >>::from_wire_option(wire)
13060        .map(Box::new)
13061    }
13062}
13063
13064/// The wire type corresponding to [`DirConnectorRouterRouteResponse`].
13065#[repr(transparent)]
13066pub struct WireDirConnectorRouterRouteResponse {
13067    raw: ::fidl_next::RawWireUnion,
13068    _phantom: ::core::marker::PhantomData<()>,
13069}
13070
13071impl Drop for WireDirConnectorRouterRouteResponse {
13072    fn drop(&mut self) {
13073        match self.raw.ordinal() {
13074            1 => {
13075                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirConnector>() };
13076            }
13077
13078            2 => {
13079                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
13080            }
13081
13082            _ => unsafe { ::core::hint::unreachable_unchecked() },
13083        }
13084    }
13085}
13086
13087unsafe impl ::fidl_next::Wire for WireDirConnectorRouterRouteResponse {
13088    type Decoded<'de> = WireDirConnectorRouterRouteResponse;
13089
13090    #[inline]
13091    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13092        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13093        ::fidl_next::RawWireUnion::zero_padding(raw);
13094    }
13095}
13096
13097pub mod dir_connector_router_route_response {
13098    pub enum Ref<'de> {
13099        DirConnector(&'de crate::WireDirConnector),
13100
13101        Unavailable(&'de crate::WireUnit),
13102    }
13103}
13104
13105impl WireDirConnectorRouterRouteResponse {
13106    pub fn as_ref(&self) -> crate::dir_connector_router_route_response::Ref<'_> {
13107        match self.raw.ordinal() {
13108            1 => crate::dir_connector_router_route_response::Ref::DirConnector(unsafe {
13109                self.raw.get().deref_unchecked::<crate::WireDirConnector>()
13110            }),
13111
13112            2 => crate::dir_connector_router_route_response::Ref::Unavailable(unsafe {
13113                self.raw.get().deref_unchecked::<crate::WireUnit>()
13114            }),
13115
13116            _ => unsafe { ::core::hint::unreachable_unchecked() },
13117        }
13118    }
13119}
13120
13121unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirConnectorRouterRouteResponse
13122where
13123    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13124    ___D: ::fidl_next::fuchsia::HandleDecoder,
13125{
13126    fn decode(
13127        mut slot: ::fidl_next::Slot<'_, Self>,
13128        decoder: &mut ___D,
13129    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13130        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13131        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13132            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirConnector>(
13133                raw, decoder,
13134            )?,
13135
13136            2 => {
13137                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13138            }
13139
13140            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13141        }
13142
13143        Ok(())
13144    }
13145}
13146
13147impl ::core::fmt::Debug for WireDirConnectorRouterRouteResponse {
13148    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13149        match self.raw.ordinal() {
13150            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirConnector>().fmt(f) },
13151            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
13152            _ => unsafe { ::core::hint::unreachable_unchecked() },
13153        }
13154    }
13155}
13156
13157#[repr(transparent)]
13158pub struct WireOptionalDirConnectorRouterRouteResponse {
13159    raw: ::fidl_next::RawWireUnion,
13160    _phantom: ::core::marker::PhantomData<()>,
13161}
13162
13163unsafe impl ::fidl_next::Wire for WireOptionalDirConnectorRouterRouteResponse {
13164    type Decoded<'de> = WireOptionalDirConnectorRouterRouteResponse;
13165
13166    #[inline]
13167    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13168        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13169        ::fidl_next::RawWireUnion::zero_padding(raw);
13170    }
13171}
13172
13173impl WireOptionalDirConnectorRouterRouteResponse {
13174    pub fn is_some(&self) -> bool {
13175        self.raw.is_some()
13176    }
13177
13178    pub fn is_none(&self) -> bool {
13179        self.raw.is_none()
13180    }
13181
13182    pub fn as_ref(&self) -> ::core::option::Option<&WireDirConnectorRouterRouteResponse> {
13183        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13184    }
13185
13186    pub fn into_option(self) -> ::core::option::Option<WireDirConnectorRouterRouteResponse> {
13187        if self.is_some() {
13188            Some(WireDirConnectorRouterRouteResponse {
13189                raw: self.raw,
13190                _phantom: ::core::marker::PhantomData,
13191            })
13192        } else {
13193            None
13194        }
13195    }
13196}
13197
13198unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirConnectorRouterRouteResponse
13199where
13200    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13201    ___D: ::fidl_next::fuchsia::HandleDecoder,
13202{
13203    fn decode(
13204        mut slot: ::fidl_next::Slot<'_, Self>,
13205        decoder: &mut ___D,
13206    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13207        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13208        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13209            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirConnector>(
13210                raw, decoder,
13211            )?,
13212
13213            2 => {
13214                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13215            }
13216
13217            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13218            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13219        }
13220
13221        Ok(())
13222    }
13223}
13224
13225impl ::core::fmt::Debug for WireOptionalDirConnectorRouterRouteResponse {
13226    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13227        self.as_ref().fmt(f)
13228    }
13229}
13230
13231/// The type corresponding to the DirConnectorRouter protocol.
13232#[derive(PartialEq, Debug)]
13233pub struct DirConnectorRouter;
13234
13235impl ::fidl_next::Discoverable for DirConnectorRouter {
13236    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
13237}
13238
13239pub mod dir_connector_router {
13240    pub mod prelude {
13241        pub use crate::{
13242            DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
13243            dir_connector_router,
13244        };
13245
13246        pub use crate::DirConnectorRouterRouteResponse;
13247
13248        pub use crate::RouteRequest;
13249
13250        pub use crate::RouterError;
13251    }
13252
13253    pub struct Route;
13254
13255    impl ::fidl_next::Method for Route {
13256        const ORDINAL: u64 = 972231070188342848;
13257
13258        type Protocol = crate::DirConnectorRouter;
13259
13260        type Request = crate::WireRouteRequest<'static>;
13261
13262        type Response = ::fidl_next::WireFlexibleResult<
13263            'static,
13264            crate::WireDirConnectorRouterRouteResponse,
13265            crate::WireRouterError,
13266        >;
13267    }
13268
13269    mod ___detail {
13270
13271        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirConnectorRouter
13272        where
13273            ___T: ::fidl_next::Transport,
13274        {
13275            type Client = DirConnectorRouterClient<___T>;
13276            type Server = DirConnectorRouterServer<___T>;
13277        }
13278
13279        /// The client for the `DirConnectorRouter` protocol.
13280        #[repr(transparent)]
13281        pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
13282            #[allow(dead_code)]
13283            client: ::fidl_next::protocol::Client<___T>,
13284        }
13285
13286        impl<___T> DirConnectorRouterClient<___T>
13287        where
13288            ___T: ::fidl_next::Transport,
13289        {
13290            pub fn route_with<___R>(
13291                &self,
13292                request: ___R,
13293            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13294            where
13295                ___R: ::fidl_next::Encode<
13296                        <___T as ::fidl_next::Transport>::SendBuffer,
13297                        Encoded = crate::WireRouteRequest<'static>,
13298                    >,
13299            {
13300                ::fidl_next::TwoWayFuture::from_untyped(
13301                    self.client.send_two_way(972231070188342848, request),
13302                )
13303            }
13304        }
13305
13306        /// The server for the `DirConnectorRouter` protocol.
13307        #[repr(transparent)]
13308        pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
13309            server: ::fidl_next::protocol::Server<___T>,
13310        }
13311
13312        impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
13313    }
13314}
13315
13316/// A client handler for the DirConnectorRouter protocol.
13317///
13318/// See [`DirConnectorRouter`] for more details.
13319pub trait DirConnectorRouterClientHandler<
13320    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13321    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13322>
13323{
13324    fn on_unknown_interaction(
13325        &mut self,
13326        ordinal: u64,
13327    ) -> impl ::core::future::Future<
13328        Output = ::core::result::Result<
13329            (),
13330            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13331        >,
13332    > + ::core::marker::Send {
13333        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13334    }
13335}
13336
13337impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
13338where
13339    ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
13340    ___T: ::fidl_next::Transport,
13341    <dir_connector_router::Route as ::fidl_next::Method>::Response:
13342        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13343{
13344    async fn on_event(
13345        handler: &mut ___H,
13346        ordinal: u64,
13347        buffer: ___T::RecvBuffer,
13348    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13349        match ordinal {
13350            ordinal => handler.on_unknown_interaction(ordinal).await,
13351        }
13352    }
13353}
13354
13355/// A server handler for the DirConnectorRouter protocol.
13356///
13357/// See [`DirConnectorRouter`] for more details.
13358pub trait DirConnectorRouterServerHandler<
13359    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13360    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13361>
13362{
13363    fn route(
13364        &mut self,
13365
13366        request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
13367
13368        responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
13369    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13370
13371    fn on_unknown_interaction(
13372        &mut self,
13373        ordinal: u64,
13374    ) -> impl ::core::future::Future<
13375        Output = ::core::result::Result<
13376            (),
13377            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13378        >,
13379    > + ::core::marker::Send {
13380        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13381    }
13382}
13383
13384impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
13385where
13386    ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
13387    ___T: ::fidl_next::Transport,
13388    <dir_connector_router::Route as ::fidl_next::Method>::Request:
13389        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13390{
13391    async fn on_one_way(
13392        handler: &mut ___H,
13393        ordinal: u64,
13394        buffer: ___T::RecvBuffer,
13395    ) -> ::core::result::Result<
13396        (),
13397        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13398    > {
13399        match ordinal {
13400            ordinal => handler.on_unknown_interaction(ordinal).await,
13401        }
13402    }
13403
13404    async fn on_two_way(
13405        handler: &mut ___H,
13406        ordinal: u64,
13407        buffer: ___T::RecvBuffer,
13408        responder: ::fidl_next::protocol::Responder<___T>,
13409    ) -> ::core::result::Result<
13410        (),
13411        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13412    > {
13413        match ordinal {
13414            972231070188342848 => {
13415                let responder = ::fidl_next::Responder::from_untyped(responder);
13416
13417                match ::fidl_next::DecoderExt::decode(buffer) {
13418                    Ok(decoded) => {
13419                        handler.route(decoded, responder).await;
13420                        Ok(())
13421                    }
13422                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13423                        ordinal: 972231070188342848,
13424                        error,
13425                    }),
13426                }
13427            }
13428
13429            ordinal => handler.on_unknown_interaction(ordinal).await,
13430        }
13431    }
13432}
13433
13434#[derive(PartialEq, Debug)]
13435pub enum DirEntryRouterRouteResponse {
13436    DirEntry(crate::DirEntry),
13437
13438    Unavailable(crate::Unit),
13439}
13440
13441impl ::fidl_next::Encodable for DirEntryRouterRouteResponse {
13442    type Encoded = WireDirEntryRouterRouteResponse;
13443}
13444
13445unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntryRouterRouteResponse
13446where
13447    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
13448    ___E: ::fidl_next::fuchsia::HandleEncoder,
13449{
13450    #[inline]
13451    fn encode(
13452        self,
13453        encoder: &mut ___E,
13454        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
13455    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13456        ::fidl_next::munge!(let WireDirEntryRouterRouteResponse { raw, _phantom: _ } = out);
13457
13458        match self {
13459            Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
13460                ___E,
13461                crate::DirEntry,
13462            >(value, 1, encoder, raw)?,
13463
13464            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
13465                ___E,
13466                crate::Unit,
13467            >(value, 2, encoder, raw)?,
13468        }
13469
13470        Ok(())
13471    }
13472}
13473
13474impl ::fidl_next::EncodableOption for DirEntryRouterRouteResponse {
13475    type EncodedOption = WireOptionalDirEntryRouterRouteResponse;
13476}
13477
13478unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntryRouterRouteResponse
13479where
13480    ___E: ?Sized,
13481    DirEntryRouterRouteResponse: ::fidl_next::Encode<___E>,
13482{
13483    #[inline]
13484    fn encode_option(
13485        this: ::core::option::Option<Self>,
13486        encoder: &mut ___E,
13487        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
13488    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13489        ::fidl_next::munge!(let WireOptionalDirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
13490
13491        if let Some(inner) = this {
13492            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
13493            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
13494        } else {
13495            ::fidl_next::RawWireUnion::encode_absent(raw);
13496        }
13497
13498        Ok(())
13499    }
13500}
13501
13502impl ::fidl_next::FromWire<WireDirEntryRouterRouteResponse> for DirEntryRouterRouteResponse {
13503    #[inline]
13504    fn from_wire(wire: WireDirEntryRouterRouteResponse) -> Self {
13505        let wire = ::core::mem::ManuallyDrop::new(wire);
13506        match wire.raw.ordinal() {
13507            1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
13508                wire.raw.get().read_unchecked::<crate::WireDirEntry>()
13509            })),
13510
13511            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
13512                wire.raw.get().read_unchecked::<crate::WireUnit>()
13513            })),
13514
13515            _ => unsafe { ::core::hint::unreachable_unchecked() },
13516        }
13517    }
13518}
13519
13520impl ::fidl_next::IntoNatural for WireDirEntryRouterRouteResponse {
13521    type Natural = DirEntryRouterRouteResponse;
13522}
13523
13524impl ::fidl_next::FromWireOption<WireOptionalDirEntryRouterRouteResponse>
13525    for DirEntryRouterRouteResponse
13526{
13527    #[inline]
13528    fn from_wire_option(
13529        wire: WireOptionalDirEntryRouterRouteResponse,
13530    ) -> ::core::option::Option<Self> {
13531        if let Some(inner) = wire.into_option() {
13532            Some(::fidl_next::FromWire::from_wire(inner))
13533        } else {
13534            None
13535        }
13536    }
13537}
13538
13539impl ::fidl_next::IntoNatural for WireOptionalDirEntryRouterRouteResponse {
13540    type Natural = ::core::option::Option<DirEntryRouterRouteResponse>;
13541}
13542
13543impl ::fidl_next::FromWireOption<WireOptionalDirEntryRouterRouteResponse>
13544    for Box<DirEntryRouterRouteResponse>
13545{
13546    #[inline]
13547    fn from_wire_option(
13548        wire: WireOptionalDirEntryRouterRouteResponse,
13549    ) -> ::core::option::Option<Self> {
13550        <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
13551            WireOptionalDirEntryRouterRouteResponse,
13552        >>::from_wire_option(wire)
13553        .map(Box::new)
13554    }
13555}
13556
13557/// The wire type corresponding to [`DirEntryRouterRouteResponse`].
13558#[repr(transparent)]
13559pub struct WireDirEntryRouterRouteResponse {
13560    raw: ::fidl_next::RawWireUnion,
13561    _phantom: ::core::marker::PhantomData<()>,
13562}
13563
13564impl Drop for WireDirEntryRouterRouteResponse {
13565    fn drop(&mut self) {
13566        match self.raw.ordinal() {
13567            1 => {
13568                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireDirEntry>() };
13569            }
13570
13571            2 => {
13572                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
13573            }
13574
13575            _ => unsafe { ::core::hint::unreachable_unchecked() },
13576        }
13577    }
13578}
13579
13580unsafe impl ::fidl_next::Wire for WireDirEntryRouterRouteResponse {
13581    type Decoded<'de> = WireDirEntryRouterRouteResponse;
13582
13583    #[inline]
13584    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13585        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13586        ::fidl_next::RawWireUnion::zero_padding(raw);
13587    }
13588}
13589
13590pub mod dir_entry_router_route_response {
13591    pub enum Ref<'de> {
13592        DirEntry(&'de crate::WireDirEntry),
13593
13594        Unavailable(&'de crate::WireUnit),
13595    }
13596}
13597
13598impl WireDirEntryRouterRouteResponse {
13599    pub fn as_ref(&self) -> crate::dir_entry_router_route_response::Ref<'_> {
13600        match self.raw.ordinal() {
13601            1 => crate::dir_entry_router_route_response::Ref::DirEntry(unsafe {
13602                self.raw.get().deref_unchecked::<crate::WireDirEntry>()
13603            }),
13604
13605            2 => crate::dir_entry_router_route_response::Ref::Unavailable(unsafe {
13606                self.raw.get().deref_unchecked::<crate::WireUnit>()
13607            }),
13608
13609            _ => unsafe { ::core::hint::unreachable_unchecked() },
13610        }
13611    }
13612}
13613
13614unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirEntryRouterRouteResponse
13615where
13616    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13617    ___D: ::fidl_next::fuchsia::HandleDecoder,
13618{
13619    fn decode(
13620        mut slot: ::fidl_next::Slot<'_, Self>,
13621        decoder: &mut ___D,
13622    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13623        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13624        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13625            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirEntry>(
13626                raw, decoder,
13627            )?,
13628
13629            2 => {
13630                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13631            }
13632
13633            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13634        }
13635
13636        Ok(())
13637    }
13638}
13639
13640impl ::core::fmt::Debug for WireDirEntryRouterRouteResponse {
13641    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13642        match self.raw.ordinal() {
13643            1 => unsafe { self.raw.get().deref_unchecked::<crate::WireDirEntry>().fmt(f) },
13644            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
13645            _ => unsafe { ::core::hint::unreachable_unchecked() },
13646        }
13647    }
13648}
13649
13650#[repr(transparent)]
13651pub struct WireOptionalDirEntryRouterRouteResponse {
13652    raw: ::fidl_next::RawWireUnion,
13653    _phantom: ::core::marker::PhantomData<()>,
13654}
13655
13656unsafe impl ::fidl_next::Wire for WireOptionalDirEntryRouterRouteResponse {
13657    type Decoded<'de> = WireOptionalDirEntryRouterRouteResponse;
13658
13659    #[inline]
13660    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13661        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13662        ::fidl_next::RawWireUnion::zero_padding(raw);
13663    }
13664}
13665
13666impl WireOptionalDirEntryRouterRouteResponse {
13667    pub fn is_some(&self) -> bool {
13668        self.raw.is_some()
13669    }
13670
13671    pub fn is_none(&self) -> bool {
13672        self.raw.is_none()
13673    }
13674
13675    pub fn as_ref(&self) -> ::core::option::Option<&WireDirEntryRouterRouteResponse> {
13676        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13677    }
13678
13679    pub fn into_option(self) -> ::core::option::Option<WireDirEntryRouterRouteResponse> {
13680        if self.is_some() {
13681            Some(WireDirEntryRouterRouteResponse {
13682                raw: self.raw,
13683                _phantom: ::core::marker::PhantomData,
13684            })
13685        } else {
13686            None
13687        }
13688    }
13689}
13690
13691unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirEntryRouterRouteResponse
13692where
13693    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13694    ___D: ::fidl_next::fuchsia::HandleDecoder,
13695{
13696    fn decode(
13697        mut slot: ::fidl_next::Slot<'_, Self>,
13698        decoder: &mut ___D,
13699    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13700        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13701        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13702            1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireDirEntry>(
13703                raw, decoder,
13704            )?,
13705
13706            2 => {
13707                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
13708            }
13709
13710            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13711            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13712        }
13713
13714        Ok(())
13715    }
13716}
13717
13718impl ::core::fmt::Debug for WireOptionalDirEntryRouterRouteResponse {
13719    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13720        self.as_ref().fmt(f)
13721    }
13722}
13723
13724/// The type corresponding to the DirEntryRouter protocol.
13725#[derive(PartialEq, Debug)]
13726pub struct DirEntryRouter;
13727
13728impl ::fidl_next::Discoverable for DirEntryRouter {
13729    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
13730}
13731
13732pub mod dir_entry_router {
13733    pub mod prelude {
13734        pub use crate::{
13735            DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
13736            dir_entry_router,
13737        };
13738
13739        pub use crate::DirEntryRouterRouteResponse;
13740
13741        pub use crate::RouteRequest;
13742
13743        pub use crate::RouterError;
13744    }
13745
13746    pub struct Route;
13747
13748    impl ::fidl_next::Method for Route {
13749        const ORDINAL: u64 = 1929392218567642066;
13750
13751        type Protocol = crate::DirEntryRouter;
13752
13753        type Request = crate::WireRouteRequest<'static>;
13754
13755        type Response = ::fidl_next::WireFlexibleResult<
13756            'static,
13757            crate::WireDirEntryRouterRouteResponse,
13758            crate::WireRouterError,
13759        >;
13760    }
13761
13762    mod ___detail {
13763
13764        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirEntryRouter
13765        where
13766            ___T: ::fidl_next::Transport,
13767        {
13768            type Client = DirEntryRouterClient<___T>;
13769            type Server = DirEntryRouterServer<___T>;
13770        }
13771
13772        /// The client for the `DirEntryRouter` protocol.
13773        #[repr(transparent)]
13774        pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
13775            #[allow(dead_code)]
13776            client: ::fidl_next::protocol::Client<___T>,
13777        }
13778
13779        impl<___T> DirEntryRouterClient<___T>
13780        where
13781            ___T: ::fidl_next::Transport,
13782        {
13783            pub fn route_with<___R>(
13784                &self,
13785                request: ___R,
13786            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
13787            where
13788                ___R: ::fidl_next::Encode<
13789                        <___T as ::fidl_next::Transport>::SendBuffer,
13790                        Encoded = crate::WireRouteRequest<'static>,
13791                    >,
13792            {
13793                ::fidl_next::TwoWayFuture::from_untyped(
13794                    self.client.send_two_way(1929392218567642066, request),
13795                )
13796            }
13797        }
13798
13799        /// The server for the `DirEntryRouter` protocol.
13800        #[repr(transparent)]
13801        pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
13802            server: ::fidl_next::protocol::Server<___T>,
13803        }
13804
13805        impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
13806    }
13807}
13808
13809/// A client handler for the DirEntryRouter protocol.
13810///
13811/// See [`DirEntryRouter`] for more details.
13812pub trait DirEntryRouterClientHandler<
13813    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13814    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13815>
13816{
13817    fn on_unknown_interaction(
13818        &mut self,
13819        ordinal: u64,
13820    ) -> impl ::core::future::Future<
13821        Output = ::core::result::Result<
13822            (),
13823            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13824        >,
13825    > + ::core::marker::Send {
13826        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13827    }
13828}
13829
13830impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
13831where
13832    ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
13833    ___T: ::fidl_next::Transport,
13834    <dir_entry_router::Route as ::fidl_next::Method>::Response:
13835        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13836{
13837    async fn on_event(
13838        handler: &mut ___H,
13839        ordinal: u64,
13840        buffer: ___T::RecvBuffer,
13841    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13842        match ordinal {
13843            ordinal => handler.on_unknown_interaction(ordinal).await,
13844        }
13845    }
13846}
13847
13848/// A server handler for the DirEntryRouter protocol.
13849///
13850/// See [`DirEntryRouter`] for more details.
13851pub trait DirEntryRouterServerHandler<
13852    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
13853    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13854>
13855{
13856    fn route(
13857        &mut self,
13858
13859        request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
13860
13861        responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
13862    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13863
13864    fn on_unknown_interaction(
13865        &mut self,
13866        ordinal: u64,
13867    ) -> impl ::core::future::Future<
13868        Output = ::core::result::Result<
13869            (),
13870            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13871        >,
13872    > + ::core::marker::Send {
13873        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
13874    }
13875}
13876
13877impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
13878where
13879    ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
13880    ___T: ::fidl_next::Transport,
13881    <dir_entry_router::Route as ::fidl_next::Method>::Request:
13882        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
13883{
13884    async fn on_one_way(
13885        handler: &mut ___H,
13886        ordinal: u64,
13887        buffer: ___T::RecvBuffer,
13888    ) -> ::core::result::Result<
13889        (),
13890        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13891    > {
13892        match ordinal {
13893            ordinal => handler.on_unknown_interaction(ordinal).await,
13894        }
13895    }
13896
13897    async fn on_two_way(
13898        handler: &mut ___H,
13899        ordinal: u64,
13900        buffer: ___T::RecvBuffer,
13901        responder: ::fidl_next::protocol::Responder<___T>,
13902    ) -> ::core::result::Result<
13903        (),
13904        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13905    > {
13906        match ordinal {
13907            1929392218567642066 => {
13908                let responder = ::fidl_next::Responder::from_untyped(responder);
13909
13910                match ::fidl_next::DecoderExt::decode(buffer) {
13911                    Ok(decoded) => {
13912                        handler.route(decoded, responder).await;
13913                        Ok(())
13914                    }
13915                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13916                        ordinal: 1929392218567642066,
13917                        error,
13918                    }),
13919                }
13920            }
13921
13922            ordinal => handler.on_unknown_interaction(ordinal).await,
13923        }
13924    }
13925}
13926
13927#[derive(PartialEq, Debug)]
13928#[repr(C)]
13929pub struct DirReceiverReceiveRequest {
13930    pub channel: ::fidl_next::ServerEnd<
13931        ::fidl_next_fuchsia_io::Directory,
13932        ::fidl_next::fuchsia::zx::Channel,
13933    >,
13934}
13935
13936impl ::fidl_next::Encodable for DirReceiverReceiveRequest {
13937    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireDirReceiverReceiveRequest> = unsafe {
13938        ::fidl_next::CopyOptimization::enable_if(
13939            true && <::fidl_next::ServerEnd<
13940                ::fidl_next_fuchsia_io::Directory,
13941                ::fidl_next::fuchsia::zx::Channel,
13942            > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
13943                .is_enabled(),
13944        )
13945    };
13946
13947    type Encoded = WireDirReceiverReceiveRequest;
13948}
13949
13950unsafe impl<___E> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest
13951where
13952    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
13953    ___E: ::fidl_next::fuchsia::HandleEncoder,
13954{
13955    #[inline]
13956    fn encode(
13957        self,
13958        encoder_: &mut ___E,
13959        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
13960    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13961        ::fidl_next::munge! {
13962            let Self::Encoded {
13963                channel,
13964
13965            } = out_;
13966        }
13967
13968        ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
13969
13970        Ok(())
13971    }
13972}
13973
13974impl ::fidl_next::EncodableOption for DirReceiverReceiveRequest {
13975    type EncodedOption = ::fidl_next::WireBox<'static, WireDirReceiverReceiveRequest>;
13976}
13977
13978unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirReceiverReceiveRequest
13979where
13980    ___E: ::fidl_next::Encoder + ?Sized,
13981    DirReceiverReceiveRequest: ::fidl_next::Encode<___E>,
13982{
13983    #[inline]
13984    fn encode_option(
13985        this: ::core::option::Option<Self>,
13986        encoder: &mut ___E,
13987        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
13988    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
13989        if let Some(inner) = this {
13990            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
13991            ::fidl_next::WireBox::encode_present(out);
13992        } else {
13993            ::fidl_next::WireBox::encode_absent(out);
13994        }
13995
13996        Ok(())
13997    }
13998}
13999
14000impl ::fidl_next::FromWire<WireDirReceiverReceiveRequest> for DirReceiverReceiveRequest {
14001    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireDirReceiverReceiveRequest, Self> = unsafe {
14002        ::fidl_next::CopyOptimization::enable_if(
14003            true && <::fidl_next::ServerEnd<
14004                ::fidl_next_fuchsia_io::Directory,
14005                ::fidl_next::fuchsia::zx::Channel,
14006            > as ::fidl_next::FromWire<
14007                ::fidl_next::ServerEnd<
14008                    ::fidl_next_fuchsia_io::Directory,
14009                    ::fidl_next::fuchsia::WireChannel,
14010                >,
14011            >>::COPY_OPTIMIZATION
14012                .is_enabled(),
14013        )
14014    };
14015
14016    #[inline]
14017    fn from_wire(wire: WireDirReceiverReceiveRequest) -> Self {
14018        Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
14019    }
14020}
14021
14022impl ::fidl_next::IntoNatural for WireDirReceiverReceiveRequest {
14023    type Natural = DirReceiverReceiveRequest;
14024}
14025
14026/// The wire type corresponding to [`DirReceiverReceiveRequest`].
14027#[derive(Debug)]
14028#[repr(C)]
14029pub struct WireDirReceiverReceiveRequest {
14030    pub channel: ::fidl_next::ServerEnd<
14031        ::fidl_next_fuchsia_io::Directory,
14032        ::fidl_next::fuchsia::WireChannel,
14033    >,
14034}
14035static_assertions::const_assert_eq!(std::mem::size_of::<WireDirReceiverReceiveRequest>(), 4);
14036static_assertions::const_assert_eq!(std::mem::align_of::<WireDirReceiverReceiveRequest>(), 4);
14037
14038static_assertions::const_assert_eq!(
14039    std::mem::offset_of!(WireDirReceiverReceiveRequest, channel),
14040    0
14041);
14042
14043unsafe impl ::fidl_next::Wire for WireDirReceiverReceiveRequest {
14044    type Decoded<'de> = WireDirReceiverReceiveRequest;
14045
14046    #[inline]
14047    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14048        ::fidl_next::munge! {
14049            let Self {
14050
14051                channel,
14052
14053            } = &mut *out_;
14054        }
14055
14056        ::fidl_next::Wire::zero_padding(channel);
14057    }
14058}
14059
14060unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirReceiverReceiveRequest
14061where
14062    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14063    ___D: ::fidl_next::fuchsia::HandleDecoder,
14064{
14065    fn decode(
14066        slot_: ::fidl_next::Slot<'_, Self>,
14067        decoder_: &mut ___D,
14068    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14069        ::fidl_next::munge! {
14070            let Self {
14071
14072                mut channel,
14073
14074            } = slot_;
14075        }
14076
14077        ::fidl_next::Decode::decode(channel.as_mut(), decoder_)?;
14078
14079        Ok(())
14080    }
14081}
14082
14083/// The type corresponding to the DirReceiver protocol.
14084#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
14085#[derive(PartialEq, Debug)]
14086pub struct DirReceiver;
14087
14088impl ::fidl_next::Discoverable for DirReceiver {
14089    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
14090}
14091
14092pub mod dir_receiver {
14093    pub mod prelude {
14094        pub use crate::{
14095            DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
14096        };
14097
14098        pub use crate::DirReceiverReceiveRequest;
14099    }
14100
14101    pub struct Receive;
14102
14103    impl ::fidl_next::Method for Receive {
14104        const ORDINAL: u64 = 926684461087488948;
14105
14106        type Protocol = crate::DirReceiver;
14107
14108        type Request = crate::WireDirReceiverReceiveRequest;
14109
14110        type Response = ::fidl_next::Never;
14111    }
14112
14113    mod ___detail {
14114
14115        pub struct Receive<T0> {
14116            channel: T0,
14117        }
14118
14119        impl<T0> ::fidl_next::Encodable for Receive<T0>
14120        where
14121            T0: ::fidl_next::Encodable<
14122                    Encoded = ::fidl_next::ServerEnd<
14123                        ::fidl_next_fuchsia_io::Directory,
14124                        ::fidl_next::fuchsia::WireChannel,
14125                    >,
14126                >,
14127        {
14128            type Encoded = crate::WireDirReceiverReceiveRequest;
14129        }
14130
14131        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Receive<T0>
14132        where
14133            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14134            ___E: ::fidl_next::fuchsia::HandleEncoder,
14135            T0: ::fidl_next::Encode<
14136                    ___E,
14137                    Encoded = ::fidl_next::ServerEnd<
14138                        ::fidl_next_fuchsia_io::Directory,
14139                        ::fidl_next::fuchsia::WireChannel,
14140                    >,
14141                >,
14142        {
14143            #[inline]
14144            fn encode(
14145                self,
14146                encoder_: &mut ___E,
14147                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14148            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14149                ::fidl_next::munge! {
14150                    let Self::Encoded {
14151                        channel,
14152
14153                    } = out_;
14154                }
14155
14156                ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
14157
14158                Ok(())
14159            }
14160        }
14161
14162        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirReceiver
14163        where
14164            ___T: ::fidl_next::Transport,
14165        {
14166            type Client = DirReceiverClient<___T>;
14167            type Server = DirReceiverServer<___T>;
14168        }
14169
14170        /// The client for the `DirReceiver` protocol.
14171        #[repr(transparent)]
14172        pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
14173            #[allow(dead_code)]
14174            client: ::fidl_next::protocol::Client<___T>,
14175        }
14176
14177        impl<___T> DirReceiverClient<___T>
14178        where
14179            ___T: ::fidl_next::Transport,
14180        {
14181            #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
14182            pub fn receive(
14183                &self,
14184
14185                channel: impl ::fidl_next::Encode<
14186                    <___T as ::fidl_next::Transport>::SendBuffer,
14187                    Encoded = ::fidl_next::ServerEnd<
14188                        ::fidl_next_fuchsia_io::Directory,
14189                        ::fidl_next::fuchsia::WireChannel,
14190                    >,
14191                >,
14192            ) -> ::fidl_next::SendFuture<'_, ___T>
14193            where
14194                <___T as ::fidl_next::Transport>::SendBuffer:
14195                    ::fidl_next::encoder::InternalHandleEncoder,
14196                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14197            {
14198                self.receive_with(Receive { channel })
14199            }
14200
14201            #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
14202            pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14203            where
14204                ___R: ::fidl_next::Encode<
14205                        <___T as ::fidl_next::Transport>::SendBuffer,
14206                        Encoded = crate::WireDirReceiverReceiveRequest,
14207                    >,
14208            {
14209                ::fidl_next::SendFuture::from_untyped(
14210                    self.client.send_one_way(926684461087488948, request),
14211                )
14212            }
14213        }
14214
14215        /// The server for the `DirReceiver` protocol.
14216        #[repr(transparent)]
14217        pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
14218            server: ::fidl_next::protocol::Server<___T>,
14219        }
14220
14221        impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
14222    }
14223}
14224
14225/// A client handler for the DirReceiver protocol.
14226///
14227/// See [`DirReceiver`] for more details.
14228pub trait DirReceiverClientHandler<
14229    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14230    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14231>
14232{
14233    fn on_unknown_interaction(
14234        &mut self,
14235        ordinal: u64,
14236    ) -> impl ::core::future::Future<
14237        Output = ::core::result::Result<
14238            (),
14239            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14240        >,
14241    > + ::core::marker::Send {
14242        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14243    }
14244}
14245
14246impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
14247where
14248    ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
14249    ___T: ::fidl_next::Transport,
14250{
14251    async fn on_event(
14252        handler: &mut ___H,
14253        ordinal: u64,
14254        buffer: ___T::RecvBuffer,
14255    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14256        match ordinal {
14257            ordinal => handler.on_unknown_interaction(ordinal).await,
14258        }
14259    }
14260}
14261
14262/// A server handler for the DirReceiver protocol.
14263///
14264/// See [`DirReceiver`] for more details.
14265pub trait DirReceiverServerHandler<
14266    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14267    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14268>
14269{
14270    #[doc = " Sends a directory channel to this receiver.\n\n The server should implement this method by forwarding `channel` to a vfs instance\n of the language appropriate `vfs` library. To keep this interface decoupled from\n `fuchsia.io`, it deliberately omits `Open`/`Open3` parameters such as `flags` and\n `path`. If a client wishes to specify these, they can obtain an initial\n [fuchsia.io/Directory] channel first and then call `Open`/`Open3` on it.\n"]
14271    fn receive(
14272        &mut self,
14273
14274        request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
14275    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14276
14277    fn on_unknown_interaction(
14278        &mut self,
14279        ordinal: u64,
14280    ) -> impl ::core::future::Future<
14281        Output = ::core::result::Result<
14282            (),
14283            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14284        >,
14285    > + ::core::marker::Send {
14286        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14287    }
14288}
14289
14290impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
14291where
14292    ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
14293    ___T: ::fidl_next::Transport,
14294    <dir_receiver::Receive as ::fidl_next::Method>::Request:
14295        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14296{
14297    async fn on_one_way(
14298        handler: &mut ___H,
14299        ordinal: u64,
14300        buffer: ___T::RecvBuffer,
14301    ) -> ::core::result::Result<
14302        (),
14303        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14304    > {
14305        match ordinal {
14306            926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
14307                Ok(decoded) => {
14308                    handler.receive(decoded).await;
14309                    Ok(())
14310                }
14311                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14312                    ordinal: 926684461087488948,
14313                    error,
14314                }),
14315            },
14316
14317            ordinal => handler.on_unknown_interaction(ordinal).await,
14318        }
14319    }
14320
14321    async fn on_two_way(
14322        handler: &mut ___H,
14323        ordinal: u64,
14324        buffer: ___T::RecvBuffer,
14325        responder: ::fidl_next::protocol::Responder<___T>,
14326    ) -> ::core::result::Result<
14327        (),
14328        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14329    > {
14330        match ordinal {
14331            ordinal => handler.on_unknown_interaction(ordinal).await,
14332        }
14333    }
14334}
14335
14336#[derive(PartialEq, Debug)]
14337pub enum DirectoryRouterRouteResponse {
14338    Directory(
14339        ::fidl_next::ClientEnd<
14340            ::fidl_next_fuchsia_io::Directory,
14341            ::fidl_next::fuchsia::zx::Channel,
14342        >,
14343    ),
14344
14345    Unavailable(crate::Unit),
14346}
14347
14348impl ::fidl_next::Encodable for DirectoryRouterRouteResponse {
14349    type Encoded = WireDirectoryRouterRouteResponse;
14350}
14351
14352unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRouterRouteResponse
14353where
14354    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14355    ___E: ::fidl_next::fuchsia::HandleEncoder,
14356{
14357    #[inline]
14358    fn encode(
14359        self,
14360        encoder: &mut ___E,
14361        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14362    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14363        ::fidl_next::munge!(let WireDirectoryRouterRouteResponse { raw, _phantom: _ } = out);
14364
14365        match self {
14366            Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
14367                ___E,
14368                ::fidl_next::ClientEnd<
14369                    ::fidl_next_fuchsia_io::Directory,
14370                    ::fidl_next::fuchsia::zx::Channel,
14371                >,
14372            >(value, 1, encoder, raw)?,
14373
14374            Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
14375                ___E,
14376                crate::Unit,
14377            >(value, 2, encoder, raw)?,
14378        }
14379
14380        Ok(())
14381    }
14382}
14383
14384impl ::fidl_next::EncodableOption for DirectoryRouterRouteResponse {
14385    type EncodedOption = WireOptionalDirectoryRouterRouteResponse;
14386}
14387
14388unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRouterRouteResponse
14389where
14390    ___E: ?Sized,
14391    DirectoryRouterRouteResponse: ::fidl_next::Encode<___E>,
14392{
14393    #[inline]
14394    fn encode_option(
14395        this: ::core::option::Option<Self>,
14396        encoder: &mut ___E,
14397        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
14398    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14399        ::fidl_next::munge!(let WireOptionalDirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
14400
14401        if let Some(inner) = this {
14402            let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
14403            ::fidl_next::Encode::encode(inner, encoder, value_out)?;
14404        } else {
14405            ::fidl_next::RawWireUnion::encode_absent(raw);
14406        }
14407
14408        Ok(())
14409    }
14410}
14411
14412impl ::fidl_next::FromWire<WireDirectoryRouterRouteResponse> for DirectoryRouterRouteResponse {
14413    #[inline]
14414    fn from_wire(wire: WireDirectoryRouterRouteResponse) -> Self {
14415        let wire = ::core::mem::ManuallyDrop::new(wire);
14416        match wire.raw.ordinal() {
14417            1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
14418                wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
14419                    ::fidl_next_fuchsia_io::Directory,
14420                    ::fidl_next::fuchsia::WireChannel,
14421                >>()
14422            })),
14423
14424            2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
14425                wire.raw.get().read_unchecked::<crate::WireUnit>()
14426            })),
14427
14428            _ => unsafe { ::core::hint::unreachable_unchecked() },
14429        }
14430    }
14431}
14432
14433impl ::fidl_next::IntoNatural for WireDirectoryRouterRouteResponse {
14434    type Natural = DirectoryRouterRouteResponse;
14435}
14436
14437impl ::fidl_next::FromWireOption<WireOptionalDirectoryRouterRouteResponse>
14438    for DirectoryRouterRouteResponse
14439{
14440    #[inline]
14441    fn from_wire_option(
14442        wire: WireOptionalDirectoryRouterRouteResponse,
14443    ) -> ::core::option::Option<Self> {
14444        if let Some(inner) = wire.into_option() {
14445            Some(::fidl_next::FromWire::from_wire(inner))
14446        } else {
14447            None
14448        }
14449    }
14450}
14451
14452impl ::fidl_next::IntoNatural for WireOptionalDirectoryRouterRouteResponse {
14453    type Natural = ::core::option::Option<DirectoryRouterRouteResponse>;
14454}
14455
14456impl ::fidl_next::FromWireOption<WireOptionalDirectoryRouterRouteResponse>
14457    for Box<DirectoryRouterRouteResponse>
14458{
14459    #[inline]
14460    fn from_wire_option(
14461        wire: WireOptionalDirectoryRouterRouteResponse,
14462    ) -> ::core::option::Option<Self> {
14463        <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
14464            WireOptionalDirectoryRouterRouteResponse,
14465        >>::from_wire_option(wire)
14466        .map(Box::new)
14467    }
14468}
14469
14470/// The wire type corresponding to [`DirectoryRouterRouteResponse`].
14471#[repr(transparent)]
14472pub struct WireDirectoryRouterRouteResponse {
14473    raw: ::fidl_next::RawWireUnion,
14474    _phantom: ::core::marker::PhantomData<()>,
14475}
14476
14477impl Drop for WireDirectoryRouterRouteResponse {
14478    fn drop(&mut self) {
14479        match self.raw.ordinal() {
14480            1 => {
14481                let _ = unsafe {
14482                    self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
14483                        ::fidl_next_fuchsia_io::Directory,
14484                        ::fidl_next::fuchsia::WireChannel,
14485                    >>()
14486                };
14487            }
14488
14489            2 => {
14490                let _ = unsafe { self.raw.get().read_unchecked::<crate::WireUnit>() };
14491            }
14492
14493            _ => unsafe { ::core::hint::unreachable_unchecked() },
14494        }
14495    }
14496}
14497
14498unsafe impl ::fidl_next::Wire for WireDirectoryRouterRouteResponse {
14499    type Decoded<'de> = WireDirectoryRouterRouteResponse;
14500
14501    #[inline]
14502    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14503        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14504        ::fidl_next::RawWireUnion::zero_padding(raw);
14505    }
14506}
14507
14508pub mod directory_router_route_response {
14509    pub enum Ref<'de> {
14510        Directory(
14511            &'de ::fidl_next::ClientEnd<
14512                ::fidl_next_fuchsia_io::Directory,
14513                ::fidl_next::fuchsia::WireChannel,
14514            >,
14515        ),
14516
14517        Unavailable(&'de crate::WireUnit),
14518    }
14519}
14520
14521impl WireDirectoryRouterRouteResponse {
14522    pub fn as_ref(&self) -> crate::directory_router_route_response::Ref<'_> {
14523        match self.raw.ordinal() {
14524            1 => crate::directory_router_route_response::Ref::Directory(unsafe {
14525                self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
14526                    ::fidl_next_fuchsia_io::Directory,
14527                    ::fidl_next::fuchsia::WireChannel,
14528                >>()
14529            }),
14530
14531            2 => crate::directory_router_route_response::Ref::Unavailable(unsafe {
14532                self.raw.get().deref_unchecked::<crate::WireUnit>()
14533            }),
14534
14535            _ => unsafe { ::core::hint::unreachable_unchecked() },
14536        }
14537    }
14538}
14539
14540unsafe impl<___D> ::fidl_next::Decode<___D> for WireDirectoryRouterRouteResponse
14541where
14542    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14543    ___D: ::fidl_next::fuchsia::HandleDecoder,
14544{
14545    fn decode(
14546        mut slot: ::fidl_next::Slot<'_, Self>,
14547        decoder: &mut ___D,
14548    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14549        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14550        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14551            1 => ::fidl_next::RawWireUnion::decode_as_static::<
14552                ___D,
14553                ::fidl_next::ClientEnd<
14554                    ::fidl_next_fuchsia_io::Directory,
14555                    ::fidl_next::fuchsia::WireChannel,
14556                >,
14557            >(raw, decoder)?,
14558
14559            2 => {
14560                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
14561            }
14562
14563            ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
14564        }
14565
14566        Ok(())
14567    }
14568}
14569
14570impl ::core::fmt::Debug for WireDirectoryRouterRouteResponse {
14571    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14572        match self.raw.ordinal() {
14573            1 => unsafe {
14574                self.raw
14575                    .get()
14576                    .deref_unchecked::<::fidl_next::ClientEnd<
14577                        ::fidl_next_fuchsia_io::Directory,
14578                        ::fidl_next::fuchsia::WireChannel,
14579                    >>()
14580                    .fmt(f)
14581            },
14582            2 => unsafe { self.raw.get().deref_unchecked::<crate::WireUnit>().fmt(f) },
14583            _ => unsafe { ::core::hint::unreachable_unchecked() },
14584        }
14585    }
14586}
14587
14588#[repr(transparent)]
14589pub struct WireOptionalDirectoryRouterRouteResponse {
14590    raw: ::fidl_next::RawWireUnion,
14591    _phantom: ::core::marker::PhantomData<()>,
14592}
14593
14594unsafe impl ::fidl_next::Wire for WireOptionalDirectoryRouterRouteResponse {
14595    type Decoded<'de> = WireOptionalDirectoryRouterRouteResponse;
14596
14597    #[inline]
14598    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14599        ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14600        ::fidl_next::RawWireUnion::zero_padding(raw);
14601    }
14602}
14603
14604impl WireOptionalDirectoryRouterRouteResponse {
14605    pub fn is_some(&self) -> bool {
14606        self.raw.is_some()
14607    }
14608
14609    pub fn is_none(&self) -> bool {
14610        self.raw.is_none()
14611    }
14612
14613    pub fn as_ref(&self) -> ::core::option::Option<&WireDirectoryRouterRouteResponse> {
14614        if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14615    }
14616
14617    pub fn into_option(self) -> ::core::option::Option<WireDirectoryRouterRouteResponse> {
14618        if self.is_some() {
14619            Some(WireDirectoryRouterRouteResponse {
14620                raw: self.raw,
14621                _phantom: ::core::marker::PhantomData,
14622            })
14623        } else {
14624            None
14625        }
14626    }
14627}
14628
14629unsafe impl<___D> ::fidl_next::Decode<___D> for WireOptionalDirectoryRouterRouteResponse
14630where
14631    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14632    ___D: ::fidl_next::fuchsia::HandleDecoder,
14633{
14634    fn decode(
14635        mut slot: ::fidl_next::Slot<'_, Self>,
14636        decoder: &mut ___D,
14637    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14638        ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14639        match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14640            1 => ::fidl_next::RawWireUnion::decode_as_static::<
14641                ___D,
14642                ::fidl_next::ClientEnd<
14643                    ::fidl_next_fuchsia_io::Directory,
14644                    ::fidl_next::fuchsia::WireChannel,
14645                >,
14646            >(raw, decoder)?,
14647
14648            2 => {
14649                ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::WireUnit>(raw, decoder)?
14650            }
14651
14652            0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14653            _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14654        }
14655
14656        Ok(())
14657    }
14658}
14659
14660impl ::core::fmt::Debug for WireOptionalDirectoryRouterRouteResponse {
14661    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14662        self.as_ref().fmt(f)
14663    }
14664}
14665
14666/// The type corresponding to the DirectoryRouter protocol.
14667#[derive(PartialEq, Debug)]
14668pub struct DirectoryRouter;
14669
14670impl ::fidl_next::Discoverable for DirectoryRouter {
14671    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
14672}
14673
14674pub mod directory_router {
14675    pub mod prelude {
14676        pub use crate::{
14677            DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
14678            directory_router,
14679        };
14680
14681        pub use crate::DirectoryRouterRouteResponse;
14682
14683        pub use crate::RouteRequest;
14684
14685        pub use crate::RouterError;
14686    }
14687
14688    pub struct Route;
14689
14690    impl ::fidl_next::Method for Route {
14691        const ORDINAL: u64 = 7510716014181158689;
14692
14693        type Protocol = crate::DirectoryRouter;
14694
14695        type Request = crate::WireRouteRequest<'static>;
14696
14697        type Response = ::fidl_next::WireFlexibleResult<
14698            'static,
14699            crate::WireDirectoryRouterRouteResponse,
14700            crate::WireRouterError,
14701        >;
14702    }
14703
14704    mod ___detail {
14705
14706        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::DirectoryRouter
14707        where
14708            ___T: ::fidl_next::Transport,
14709        {
14710            type Client = DirectoryRouterClient<___T>;
14711            type Server = DirectoryRouterServer<___T>;
14712        }
14713
14714        /// The client for the `DirectoryRouter` protocol.
14715        #[repr(transparent)]
14716        pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
14717            #[allow(dead_code)]
14718            client: ::fidl_next::protocol::Client<___T>,
14719        }
14720
14721        impl<___T> DirectoryRouterClient<___T>
14722        where
14723            ___T: ::fidl_next::Transport,
14724        {
14725            pub fn route_with<___R>(
14726                &self,
14727                request: ___R,
14728            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
14729            where
14730                ___R: ::fidl_next::Encode<
14731                        <___T as ::fidl_next::Transport>::SendBuffer,
14732                        Encoded = crate::WireRouteRequest<'static>,
14733                    >,
14734            {
14735                ::fidl_next::TwoWayFuture::from_untyped(
14736                    self.client.send_two_way(7510716014181158689, request),
14737                )
14738            }
14739        }
14740
14741        /// The server for the `DirectoryRouter` protocol.
14742        #[repr(transparent)]
14743        pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
14744            server: ::fidl_next::protocol::Server<___T>,
14745        }
14746
14747        impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
14748    }
14749}
14750
14751/// A client handler for the DirectoryRouter protocol.
14752///
14753/// See [`DirectoryRouter`] for more details.
14754pub trait DirectoryRouterClientHandler<
14755    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14756    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14757>
14758{
14759    fn on_unknown_interaction(
14760        &mut self,
14761        ordinal: u64,
14762    ) -> impl ::core::future::Future<
14763        Output = ::core::result::Result<
14764            (),
14765            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14766        >,
14767    > + ::core::marker::Send {
14768        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14769    }
14770}
14771
14772impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
14773where
14774    ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
14775    ___T: ::fidl_next::Transport,
14776    <directory_router::Route as ::fidl_next::Method>::Response:
14777        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14778{
14779    async fn on_event(
14780        handler: &mut ___H,
14781        ordinal: u64,
14782        buffer: ___T::RecvBuffer,
14783    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
14784        match ordinal {
14785            ordinal => handler.on_unknown_interaction(ordinal).await,
14786        }
14787    }
14788}
14789
14790/// A server handler for the DirectoryRouter protocol.
14791///
14792/// See [`DirectoryRouter`] for more details.
14793pub trait DirectoryRouterServerHandler<
14794    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
14795    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
14796>
14797{
14798    fn route(
14799        &mut self,
14800
14801        request: ::fidl_next::Request<directory_router::Route, ___T>,
14802
14803        responder: ::fidl_next::Responder<directory_router::Route, ___T>,
14804    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
14805
14806    fn on_unknown_interaction(
14807        &mut self,
14808        ordinal: u64,
14809    ) -> impl ::core::future::Future<
14810        Output = ::core::result::Result<
14811            (),
14812            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14813        >,
14814    > + ::core::marker::Send {
14815        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
14816    }
14817}
14818
14819impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
14820where
14821    ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
14822    ___T: ::fidl_next::Transport,
14823    <directory_router::Route as ::fidl_next::Method>::Request:
14824        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
14825{
14826    async fn on_one_way(
14827        handler: &mut ___H,
14828        ordinal: u64,
14829        buffer: ___T::RecvBuffer,
14830    ) -> ::core::result::Result<
14831        (),
14832        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14833    > {
14834        match ordinal {
14835            ordinal => handler.on_unknown_interaction(ordinal).await,
14836        }
14837    }
14838
14839    async fn on_two_way(
14840        handler: &mut ___H,
14841        ordinal: u64,
14842        buffer: ___T::RecvBuffer,
14843        responder: ::fidl_next::protocol::Responder<___T>,
14844    ) -> ::core::result::Result<
14845        (),
14846        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
14847    > {
14848        match ordinal {
14849            7510716014181158689 => {
14850                let responder = ::fidl_next::Responder::from_untyped(responder);
14851
14852                match ::fidl_next::DecoderExt::decode(buffer) {
14853                    Ok(decoded) => {
14854                        handler.route(decoded, responder).await;
14855                        Ok(())
14856                    }
14857                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
14858                        ordinal: 7510716014181158689,
14859                        error,
14860                    }),
14861                }
14862            }
14863
14864            ordinal => handler.on_unknown_interaction(ordinal).await,
14865        }
14866    }
14867}
14868
14869#[doc = " Contains a protocol open request.\n"]
14870#[derive(PartialEq, Debug)]
14871#[repr(C)]
14872pub struct ProtocolPayload {
14873    pub channel: ::fidl_next::fuchsia::zx::Channel,
14874}
14875
14876impl ::fidl_next::Encodable for ProtocolPayload {
14877    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireProtocolPayload> = unsafe {
14878        ::fidl_next::CopyOptimization::enable_if(
14879            true
14880                && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encodable>::COPY_OPTIMIZATION
14881                    .is_enabled(),
14882        )
14883    };
14884
14885    type Encoded = WireProtocolPayload;
14886}
14887
14888unsafe impl<___E> ::fidl_next::Encode<___E> for ProtocolPayload
14889where
14890    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14891    ___E: ::fidl_next::fuchsia::HandleEncoder,
14892{
14893    #[inline]
14894    fn encode(
14895        self,
14896        encoder_: &mut ___E,
14897        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14898    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14899        ::fidl_next::munge! {
14900            let Self::Encoded {
14901                channel,
14902
14903            } = out_;
14904        }
14905
14906        ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
14907
14908        Ok(())
14909    }
14910}
14911
14912impl ::fidl_next::EncodableOption for ProtocolPayload {
14913    type EncodedOption = ::fidl_next::WireBox<'static, WireProtocolPayload>;
14914}
14915
14916unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ProtocolPayload
14917where
14918    ___E: ::fidl_next::Encoder + ?Sized,
14919    ProtocolPayload: ::fidl_next::Encode<___E>,
14920{
14921    #[inline]
14922    fn encode_option(
14923        this: ::core::option::Option<Self>,
14924        encoder: &mut ___E,
14925        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
14926    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14927        if let Some(inner) = this {
14928            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
14929            ::fidl_next::WireBox::encode_present(out);
14930        } else {
14931            ::fidl_next::WireBox::encode_absent(out);
14932        }
14933
14934        Ok(())
14935    }
14936}
14937
14938impl ::fidl_next::FromWire<WireProtocolPayload> for ProtocolPayload {
14939    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireProtocolPayload, Self> = unsafe {
14940        ::fidl_next::CopyOptimization::enable_if(
14941            true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
14942                ::fidl_next::fuchsia::WireChannel,
14943            >>::COPY_OPTIMIZATION
14944                .is_enabled(),
14945        )
14946    };
14947
14948    #[inline]
14949    fn from_wire(wire: WireProtocolPayload) -> Self {
14950        Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
14951    }
14952}
14953
14954impl ::fidl_next::IntoNatural for WireProtocolPayload {
14955    type Natural = ProtocolPayload;
14956}
14957
14958/// The wire type corresponding to [`ProtocolPayload`].
14959#[derive(Debug)]
14960#[repr(C)]
14961pub struct WireProtocolPayload {
14962    pub channel: ::fidl_next::fuchsia::WireChannel,
14963}
14964static_assertions::const_assert_eq!(std::mem::size_of::<WireProtocolPayload>(), 4);
14965static_assertions::const_assert_eq!(std::mem::align_of::<WireProtocolPayload>(), 4);
14966
14967static_assertions::const_assert_eq!(std::mem::offset_of!(WireProtocolPayload, channel), 0);
14968
14969unsafe impl ::fidl_next::Wire for WireProtocolPayload {
14970    type Decoded<'de> = WireProtocolPayload;
14971
14972    #[inline]
14973    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14974        ::fidl_next::munge! {
14975            let Self {
14976
14977                channel,
14978
14979            } = &mut *out_;
14980        }
14981
14982        ::fidl_next::Wire::zero_padding(channel);
14983    }
14984}
14985
14986unsafe impl<___D> ::fidl_next::Decode<___D> for WireProtocolPayload
14987where
14988    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14989    ___D: ::fidl_next::fuchsia::HandleDecoder,
14990{
14991    fn decode(
14992        slot_: ::fidl_next::Slot<'_, Self>,
14993        decoder_: &mut ___D,
14994    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14995        ::fidl_next::munge! {
14996            let Self {
14997
14998                mut channel,
14999
15000            } = slot_;
15001        }
15002
15003        ::fidl_next::Decode::decode(channel.as_mut(), decoder_)?;
15004
15005        Ok(())
15006    }
15007}
15008
15009/// The type corresponding to the Receiver protocol.
15010#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
15011#[derive(PartialEq, Debug)]
15012pub struct Receiver;
15013
15014impl ::fidl_next::Discoverable for Receiver {
15015    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
15016}
15017
15018pub mod receiver {
15019    pub mod prelude {
15020        pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
15021
15022        pub use crate::ProtocolPayload;
15023    }
15024
15025    pub struct Receive;
15026
15027    impl ::fidl_next::Method for Receive {
15028        const ORDINAL: u64 = 340832707723008660;
15029
15030        type Protocol = crate::Receiver;
15031
15032        type Request = crate::WireProtocolPayload;
15033
15034        type Response = ::fidl_next::Never;
15035    }
15036
15037    mod ___detail {
15038
15039        pub struct Receive<T0> {
15040            channel: T0,
15041        }
15042
15043        impl<T0> ::fidl_next::Encodable for Receive<T0>
15044        where
15045            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
15046        {
15047            type Encoded = crate::WireProtocolPayload;
15048        }
15049
15050        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Receive<T0>
15051        where
15052            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15053            ___E: ::fidl_next::fuchsia::HandleEncoder,
15054            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
15055        {
15056            #[inline]
15057            fn encode(
15058                self,
15059                encoder_: &mut ___E,
15060                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15061            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15062                ::fidl_next::munge! {
15063                    let Self::Encoded {
15064                        channel,
15065
15066                    } = out_;
15067                }
15068
15069                ::fidl_next::Encode::encode(self.channel, encoder_, channel)?;
15070
15071                Ok(())
15072            }
15073        }
15074
15075        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Receiver
15076        where
15077            ___T: ::fidl_next::Transport,
15078        {
15079            type Client = ReceiverClient<___T>;
15080            type Server = ReceiverServer<___T>;
15081        }
15082
15083        /// The client for the `Receiver` protocol.
15084        #[repr(transparent)]
15085        pub struct ReceiverClient<___T: ::fidl_next::Transport> {
15086            #[allow(dead_code)]
15087            client: ::fidl_next::protocol::Client<___T>,
15088        }
15089
15090        impl<___T> ReceiverClient<___T>
15091        where
15092            ___T: ::fidl_next::Transport,
15093        {
15094            #[doc = " Sends a channel to this receiver.\n"]
15095            pub fn receive(
15096                &self,
15097
15098                channel: impl ::fidl_next::Encode<
15099                    <___T as ::fidl_next::Transport>::SendBuffer,
15100                    Encoded = ::fidl_next::fuchsia::WireChannel,
15101                >,
15102            ) -> ::fidl_next::SendFuture<'_, ___T>
15103            where
15104                <___T as ::fidl_next::Transport>::SendBuffer:
15105                    ::fidl_next::encoder::InternalHandleEncoder,
15106                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15107            {
15108                self.receive_with(Receive { channel })
15109            }
15110
15111            #[doc = " Sends a channel to this receiver.\n"]
15112            pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
15113            where
15114                ___R: ::fidl_next::Encode<
15115                        <___T as ::fidl_next::Transport>::SendBuffer,
15116                        Encoded = crate::WireProtocolPayload,
15117                    >,
15118            {
15119                ::fidl_next::SendFuture::from_untyped(
15120                    self.client.send_one_way(340832707723008660, request),
15121                )
15122            }
15123        }
15124
15125        /// The server for the `Receiver` protocol.
15126        #[repr(transparent)]
15127        pub struct ReceiverServer<___T: ::fidl_next::Transport> {
15128            server: ::fidl_next::protocol::Server<___T>,
15129        }
15130
15131        impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
15132    }
15133}
15134
15135/// A client handler for the Receiver protocol.
15136///
15137/// See [`Receiver`] for more details.
15138pub trait ReceiverClientHandler<
15139    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
15140    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15141>
15142{
15143    fn on_unknown_interaction(
15144        &mut self,
15145        ordinal: u64,
15146    ) -> impl ::core::future::Future<
15147        Output = ::core::result::Result<
15148            (),
15149            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15150        >,
15151    > + ::core::marker::Send {
15152        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
15153    }
15154}
15155
15156impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
15157where
15158    ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
15159    ___T: ::fidl_next::Transport,
15160{
15161    async fn on_event(
15162        handler: &mut ___H,
15163        ordinal: u64,
15164        buffer: ___T::RecvBuffer,
15165    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15166        match ordinal {
15167            ordinal => handler.on_unknown_interaction(ordinal).await,
15168        }
15169    }
15170}
15171
15172/// A server handler for the Receiver protocol.
15173///
15174/// See [`Receiver`] for more details.
15175pub trait ReceiverServerHandler<
15176    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
15177    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15178>
15179{
15180    #[doc = " Sends a channel to this receiver.\n"]
15181    fn receive(
15182        &mut self,
15183
15184        request: ::fidl_next::Request<receiver::Receive, ___T>,
15185    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
15186
15187    fn on_unknown_interaction(
15188        &mut self,
15189        ordinal: u64,
15190    ) -> impl ::core::future::Future<
15191        Output = ::core::result::Result<
15192            (),
15193            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15194        >,
15195    > + ::core::marker::Send {
15196        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
15197    }
15198}
15199
15200impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
15201where
15202    ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
15203    ___T: ::fidl_next::Transport,
15204    <receiver::Receive as ::fidl_next::Method>::Request:
15205        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
15206{
15207    async fn on_one_way(
15208        handler: &mut ___H,
15209        ordinal: u64,
15210        buffer: ___T::RecvBuffer,
15211    ) -> ::core::result::Result<
15212        (),
15213        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15214    > {
15215        match ordinal {
15216            340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
15217                Ok(decoded) => {
15218                    handler.receive(decoded).await;
15219                    Ok(())
15220                }
15221                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15222                    ordinal: 340832707723008660,
15223                    error,
15224                }),
15225            },
15226
15227            ordinal => handler.on_unknown_interaction(ordinal).await,
15228        }
15229    }
15230
15231    async fn on_two_way(
15232        handler: &mut ___H,
15233        ordinal: u64,
15234        buffer: ___T::RecvBuffer,
15235        responder: ::fidl_next::protocol::Responder<___T>,
15236    ) -> ::core::result::Result<
15237        (),
15238        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
15239    > {
15240        match ordinal {
15241            ordinal => handler.on_unknown_interaction(ordinal).await,
15242        }
15243    }
15244}
15245
15246#[derive(PartialEq, Clone, Debug)]
15247#[repr(C)]
15248pub struct Unavailable {}
15249
15250impl ::fidl_next::Encodable for Unavailable {
15251    type Encoded = WireUnavailable;
15252}
15253
15254unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
15255where
15256    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15257{
15258    #[inline]
15259    fn encode(
15260        self,
15261        encoder_: &mut ___E,
15262        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15263    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15264        *out_ = ::core::mem::MaybeUninit::zeroed();
15265
15266        Ok(())
15267    }
15268}
15269
15270unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unavailable
15271where
15272    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15273{
15274    #[inline]
15275    fn encode_ref(
15276        &self,
15277        encoder_: &mut ___E,
15278        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15279    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15280        ::fidl_next::munge! {
15281            let Self::Encoded {
15282
15283                    _empty,
15284
15285
15286            } = out_;
15287        }
15288
15289        Ok(())
15290    }
15291}
15292
15293impl ::fidl_next::EncodableOption for Unavailable {
15294    type EncodedOption = ::fidl_next::WireBox<'static, WireUnavailable>;
15295}
15296
15297unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unavailable
15298where
15299    ___E: ::fidl_next::Encoder + ?Sized,
15300    Unavailable: ::fidl_next::Encode<___E>,
15301{
15302    #[inline]
15303    fn encode_option(
15304        this: ::core::option::Option<Self>,
15305        encoder: &mut ___E,
15306        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
15307    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15308        if let Some(inner) = this {
15309            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
15310            ::fidl_next::WireBox::encode_present(out);
15311        } else {
15312            ::fidl_next::WireBox::encode_absent(out);
15313        }
15314
15315        Ok(())
15316    }
15317}
15318
15319unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unavailable
15320where
15321    ___E: ::fidl_next::Encoder + ?Sized,
15322    Unavailable: ::fidl_next::EncodeRef<___E>,
15323{
15324    #[inline]
15325    fn encode_option_ref(
15326        this: ::core::option::Option<&Self>,
15327        encoder: &mut ___E,
15328        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
15329    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15330        if let Some(inner) = this {
15331            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
15332            ::fidl_next::WireBox::encode_present(out);
15333        } else {
15334            ::fidl_next::WireBox::encode_absent(out);
15335        }
15336
15337        Ok(())
15338    }
15339}
15340
15341impl ::fidl_next::FromWire<WireUnavailable> for Unavailable {
15342    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireUnavailable, Self> =
15343        unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
15344
15345    #[inline]
15346    fn from_wire(wire: WireUnavailable) -> Self {
15347        Self {}
15348    }
15349}
15350
15351impl ::fidl_next::IntoNatural for WireUnavailable {
15352    type Natural = Unavailable;
15353}
15354
15355impl ::fidl_next::FromWireRef<WireUnavailable> for Unavailable {
15356    #[inline]
15357    fn from_wire_ref(wire: &WireUnavailable) -> Self {
15358        Self {}
15359    }
15360}
15361
15362/// The wire type corresponding to [`Unavailable`].
15363#[derive(Clone, Debug)]
15364#[repr(C)]
15365pub struct WireUnavailable {
15366    _empty: fidl_next::WireEmptyStructPlaceholder,
15367}
15368static_assertions::const_assert_eq!(std::mem::size_of::<WireUnavailable>(), 1);
15369static_assertions::const_assert_eq!(std::mem::align_of::<WireUnavailable>(), 1);
15370
15371unsafe impl ::fidl_next::Wire for WireUnavailable {
15372    type Decoded<'de> = WireUnavailable;
15373
15374    #[inline]
15375    fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15376        ::fidl_next::munge! {
15377            let Self {
15378
15379                    _empty,
15380
15381
15382            } = &mut *out_;
15383        }
15384    }
15385}
15386
15387unsafe impl<___D> ::fidl_next::Decode<___D> for WireUnavailable
15388where
15389    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15390{
15391    fn decode(
15392        slot_: ::fidl_next::Slot<'_, Self>,
15393        decoder_: &mut ___D,
15394    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15395        ::fidl_next::munge! {
15396            let Self {
15397
15398                    mut _empty,
15399
15400
15401            } = slot_;
15402        }
15403
15404        if _empty.as_bytes() != &[0u8] {
15405            return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
15406        }
15407
15408        Ok(())
15409    }
15410}
15411
15412/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
15413pub mod compat {
15414
15415    impl ::fidl_next::CompatFrom<crate::Availability>
15416        for ::fidl_fuchsia_component_sandbox::Availability
15417    {
15418        fn compat_from(value: crate::Availability) -> Self {
15419            match value {
15420                crate::Availability::Required => Self::Required,
15421
15422                crate::Availability::Optional => Self::Optional,
15423
15424                crate::Availability::SameAsTarget => Self::SameAsTarget,
15425
15426                crate::Availability::Transitional => Self::Transitional,
15427            }
15428        }
15429    }
15430
15431    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Availability>
15432        for crate::Availability
15433    {
15434        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Availability) -> Self {
15435            match value {
15436                ::fidl_fuchsia_component_sandbox::Availability::Required => Self::Required,
15437
15438                ::fidl_fuchsia_component_sandbox::Availability::Optional => Self::Optional,
15439
15440                ::fidl_fuchsia_component_sandbox::Availability::SameAsTarget => Self::SameAsTarget,
15441
15442                ::fidl_fuchsia_component_sandbox::Availability::Transitional => Self::Transitional,
15443            }
15444        }
15445    }
15446
15447    impl ::fidl_next::CompatFrom<crate::Unit> for ::fidl_fuchsia_component_sandbox::Unit {
15448        #[inline]
15449        fn compat_from(value: crate::Unit) -> Self {
15450            Self {}
15451        }
15452    }
15453
15454    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unit> for crate::Unit {
15455        #[inline]
15456        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unit) -> Self {
15457            Self {}
15458        }
15459    }
15460
15461    impl ::fidl_next::CompatFrom<crate::Data> for ::fidl_fuchsia_component_sandbox::Data {
15462        fn compat_from(value: crate::Data) -> Self {
15463            match value {
15464                crate::Data::Bytes(value) => {
15465                    Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15466                }
15467
15468                crate::Data::String(value) => {
15469                    Self::String(::fidl_next::CompatFrom::compat_from(value))
15470                }
15471
15472                crate::Data::Int64(value) => {
15473                    Self::Int64(::fidl_next::CompatFrom::compat_from(value))
15474                }
15475
15476                crate::Data::Uint64(value) => {
15477                    Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
15478                }
15479
15480                crate::Data::UnknownOrdinal_(unknown_ordinal) => {
15481                    Self::__SourceBreaking { unknown_ordinal }
15482                }
15483            }
15484        }
15485    }
15486
15487    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Data> for crate::Data {
15488        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Data) -> Self {
15489            match value {
15490                ::fidl_fuchsia_component_sandbox::Data::Bytes(value) => {
15491                    Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
15492                }
15493
15494                ::fidl_fuchsia_component_sandbox::Data::String(value) => {
15495                    Self::String(::fidl_next::CompatFrom::compat_from(value))
15496                }
15497
15498                ::fidl_fuchsia_component_sandbox::Data::Int64(value) => {
15499                    Self::Int64(::fidl_next::CompatFrom::compat_from(value))
15500                }
15501
15502                ::fidl_fuchsia_component_sandbox::Data::Uint64(value) => {
15503                    Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
15504                }
15505
15506                ::fidl_fuchsia_component_sandbox::Data::__SourceBreaking { unknown_ordinal } => {
15507                    Self::UnknownOrdinal_(unknown_ordinal)
15508                }
15509            }
15510        }
15511    }
15512
15513    impl ::fidl_next::CompatFrom<crate::DictionaryRef>
15514        for ::fidl_fuchsia_component_sandbox::DictionaryRef
15515    {
15516        #[inline]
15517        fn compat_from(value: crate::DictionaryRef) -> Self {
15518            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15519        }
15520    }
15521
15522    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
15523        for crate::DictionaryRef
15524    {
15525        #[inline]
15526        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
15527            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15528        }
15529    }
15530
15531    impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
15532        #[inline]
15533        fn compat_from(value: crate::Connector) -> Self {
15534            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15535        }
15536    }
15537
15538    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
15539        #[inline]
15540        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
15541            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15542        }
15543    }
15544
15545    impl ::fidl_next::CompatFrom<crate::DirConnector>
15546        for ::fidl_fuchsia_component_sandbox::DirConnector
15547    {
15548        #[inline]
15549        fn compat_from(value: crate::DirConnector) -> Self {
15550            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15551        }
15552    }
15553
15554    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
15555        for crate::DirConnector
15556    {
15557        #[inline]
15558        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
15559            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15560        }
15561    }
15562
15563    impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
15564        #[inline]
15565        fn compat_from(value: crate::DirEntry) -> Self {
15566            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15567        }
15568    }
15569
15570    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
15571        #[inline]
15572        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
15573            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
15574        }
15575    }
15576
15577    impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
15578        fn compat_from(value: crate::Capability) -> Self {
15579            match value {
15580                crate::Capability::Unit(value) => {
15581                    Self::Unit(::fidl_next::CompatFrom::compat_from(value))
15582                }
15583
15584                crate::Capability::Handle(value) => {
15585                    Self::Handle(::fidl_next::CompatFrom::compat_from(value))
15586                }
15587
15588                crate::Capability::Data(value) => {
15589                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
15590                }
15591
15592                crate::Capability::Dictionary(value) => {
15593                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
15594                }
15595
15596                crate::Capability::Connector(value) => {
15597                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
15598                }
15599
15600                crate::Capability::DirConnector(value) => {
15601                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
15602                }
15603
15604                crate::Capability::Directory(value) => {
15605                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15606                }
15607
15608                crate::Capability::DirEntry(value) => {
15609                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15610                }
15611
15612                crate::Capability::ConnectorRouter(value) => {
15613                    Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15614                }
15615
15616                crate::Capability::DictionaryRouter(value) => {
15617                    Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
15618                }
15619
15620                crate::Capability::DirEntryRouter(value) => {
15621                    Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
15622                }
15623
15624                crate::Capability::DataRouter(value) => {
15625                    Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
15626                }
15627
15628                crate::Capability::DirConnectorRouter(value) => {
15629                    Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15630                }
15631
15632                crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
15633                    Self::__SourceBreaking { unknown_ordinal }
15634                }
15635            }
15636        }
15637    }
15638
15639    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
15640        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
15641            match value {
15642                ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
15643                    Self::Unit(::fidl_next::CompatFrom::compat_from(value))
15644                }
15645
15646                ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
15647                    Self::Handle(::fidl_next::CompatFrom::compat_from(value))
15648                }
15649
15650                ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
15651                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
15652                }
15653
15654                ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
15655                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
15656                }
15657
15658                ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
15659                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
15660                }
15661
15662                ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
15663                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
15664                }
15665
15666                ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
15667                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
15668                }
15669
15670                ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
15671                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
15672                }
15673
15674                ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
15675                    Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15676                }
15677
15678                ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
15679                    Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
15680                }
15681
15682                ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
15683                    Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
15684                }
15685
15686                ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
15687                    Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
15688                }
15689
15690                ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
15691                    Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
15692                }
15693
15694                ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
15695                    unknown_ordinal,
15696                } => Self::UnknownOrdinal_(unknown_ordinal),
15697            }
15698        }
15699    }
15700
15701    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDuplicateRequest>
15702        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
15703    {
15704        #[inline]
15705        fn compat_from(value: crate::CapabilityStoreDuplicateRequest) -> Self {
15706            Self {
15707                id: ::fidl_next::CompatFrom::compat_from(value.id),
15708
15709                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
15710            }
15711        }
15712    }
15713
15714    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest>
15715        for crate::CapabilityStoreDuplicateRequest
15716    {
15717        #[inline]
15718        fn compat_from(
15719            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest,
15720        ) -> Self {
15721            Self {
15722                id: ::fidl_next::CompatFrom::compat_from(value.id),
15723
15724                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
15725            }
15726        }
15727    }
15728
15729    impl ::fidl_next::CompatFrom<crate::CapabilityStoreError>
15730        for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
15731    {
15732        fn compat_from(value: crate::CapabilityStoreError) -> Self {
15733            match value {
15734                crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,
15735
15736                crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,
15737
15738                crate::CapabilityStoreError::BadCapability => Self::BadCapability,
15739
15740                crate::CapabilityStoreError::WrongType => Self::WrongType,
15741
15742                crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,
15743
15744                crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,
15745
15746                crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,
15747
15748                crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,
15749
15750                crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,
15751
15752                crate::CapabilityStoreError::UnknownOrdinal_(unknown_ordinal) => {
15753                    Self::__SourceBreaking { unknown_ordinal }
15754                }
15755            }
15756        }
15757    }
15758
15759    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreError>
15760        for crate::CapabilityStoreError
15761    {
15762        fn compat_from(value: ::fidl_fuchsia_component_sandbox::CapabilityStoreError) -> Self {
15763            match value {
15764                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdNotFound => {
15765                    Self::IdNotFound
15766                }
15767
15768                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdAlreadyExists => {
15769                    Self::IdAlreadyExists
15770                }
15771
15772                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::BadCapability => {
15773                    Self::BadCapability
15774                }
15775
15776                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::WrongType => {
15777                    Self::WrongType
15778                }
15779
15780                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::NotDuplicatable => {
15781                    Self::NotDuplicatable
15782                }
15783
15784                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemNotFound => {
15785                    Self::ItemNotFound
15786                }
15787
15788                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemAlreadyExists => {
15789                    Self::ItemAlreadyExists
15790                }
15791
15792                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidKey => {
15793                    Self::InvalidKey
15794                }
15795
15796                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidArgs => {
15797                    Self::InvalidArgs
15798                }
15799
15800                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::__SourceBreaking {
15801                    unknown_ordinal: value,
15802                } => Self::UnknownOrdinal_(value),
15803            }
15804        }
15805    }
15806
15807    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDropRequest>
15808        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
15809    {
15810        #[inline]
15811        fn compat_from(value: crate::CapabilityStoreDropRequest) -> Self {
15812            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15813        }
15814    }
15815
15816    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest>
15817        for crate::CapabilityStoreDropRequest
15818    {
15819        #[inline]
15820        fn compat_from(
15821            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest,
15822        ) -> Self {
15823            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15824        }
15825    }
15826
15827    impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportRequest>
15828        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
15829    {
15830        #[inline]
15831        fn compat_from(value: crate::CapabilityStoreExportRequest) -> Self {
15832            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15833        }
15834    }
15835
15836    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest>
15837        for crate::CapabilityStoreExportRequest
15838    {
15839        #[inline]
15840        fn compat_from(
15841            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest,
15842        ) -> Self {
15843            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15844        }
15845    }
15846
15847    impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
15848        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
15849    {
15850        #[inline]
15851        fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
15852            Self {
15853                id: ::fidl_next::CompatFrom::compat_from(value.id),
15854
15855                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
15856            }
15857        }
15858    }
15859
15860    impl
15861        ::fidl_next::CompatFrom<
15862            ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
15863        > for crate::CapabilityStoreConnectorCreateRequest
15864    {
15865        #[inline]
15866        fn compat_from(
15867            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
15868        ) -> Self {
15869            Self {
15870                id: ::fidl_next::CompatFrom::compat_from(value.id),
15871
15872                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
15873            }
15874        }
15875    }
15876
15877    impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
15878        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
15879    {
15880        #[inline]
15881        fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
15882            Self {
15883                id: ::fidl_next::CompatFrom::compat_from(value.id),
15884
15885                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15886            }
15887        }
15888    }
15889
15890    impl
15891        ::fidl_next::CompatFrom<
15892            ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
15893        > for crate::CapabilityStoreConnectorOpenRequest
15894    {
15895        #[inline]
15896        fn compat_from(
15897            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
15898        ) -> Self {
15899            Self {
15900                id: ::fidl_next::CompatFrom::compat_from(value.id),
15901
15902                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15903            }
15904        }
15905    }
15906
15907    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCreateRequest>
15908        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
15909    {
15910        #[inline]
15911        fn compat_from(value: crate::CapabilityStoreDictionaryCreateRequest) -> Self {
15912            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15913        }
15914    }
15915
15916    impl
15917        ::fidl_next::CompatFrom<
15918            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
15919        > for crate::CapabilityStoreDictionaryCreateRequest
15920    {
15921        #[inline]
15922        fn compat_from(
15923            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
15924        ) -> Self {
15925            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
15926        }
15927    }
15928
15929    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
15930        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
15931    {
15932        #[inline]
15933        fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
15934            Self {
15935                id: ::fidl_next::CompatFrom::compat_from(value.id),
15936
15937                client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
15938            }
15939        }
15940    }
15941
15942    impl
15943        ::fidl_next::CompatFrom<
15944            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
15945        > for crate::CapabilityStoreDictionaryLegacyImportRequest
15946    {
15947        #[inline]
15948        fn compat_from(
15949            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
15950        ) -> Self {
15951            Self {
15952                id: ::fidl_next::CompatFrom::compat_from(value.id),
15953
15954                client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
15955            }
15956        }
15957    }
15958
15959    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
15960        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
15961    {
15962        #[inline]
15963        fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
15964            Self {
15965                id: ::fidl_next::CompatFrom::compat_from(value.id),
15966
15967                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15968            }
15969        }
15970    }
15971
15972    impl
15973        ::fidl_next::CompatFrom<
15974            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
15975        > for crate::CapabilityStoreDictionaryLegacyExportRequest
15976    {
15977        #[inline]
15978        fn compat_from(
15979            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
15980        ) -> Self {
15981            Self {
15982                id: ::fidl_next::CompatFrom::compat_from(value.id),
15983
15984                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
15985            }
15986        }
15987    }
15988
15989    impl ::fidl_next::CompatFrom<crate::DictionaryItem>
15990        for ::fidl_fuchsia_component_sandbox::DictionaryItem
15991    {
15992        #[inline]
15993        fn compat_from(value: crate::DictionaryItem) -> Self {
15994            Self {
15995                key: ::fidl_next::CompatFrom::compat_from(value.key),
15996
15997                value: ::fidl_next::CompatFrom::compat_from(value.value),
15998            }
15999        }
16000    }
16001
16002    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryItem>
16003        for crate::DictionaryItem
16004    {
16005        #[inline]
16006        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryItem) -> Self {
16007            Self {
16008                key: ::fidl_next::CompatFrom::compat_from(value.key),
16009
16010                value: ::fidl_next::CompatFrom::compat_from(value.value),
16011            }
16012        }
16013    }
16014
16015    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryInsertRequest>
16016        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
16017    {
16018        #[inline]
16019        fn compat_from(value: crate::CapabilityStoreDictionaryInsertRequest) -> Self {
16020            Self {
16021                id: ::fidl_next::CompatFrom::compat_from(value.id),
16022
16023                item: ::fidl_next::CompatFrom::compat_from(value.item),
16024            }
16025        }
16026    }
16027
16028    impl
16029        ::fidl_next::CompatFrom<
16030            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
16031        > for crate::CapabilityStoreDictionaryInsertRequest
16032    {
16033        #[inline]
16034        fn compat_from(
16035            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
16036        ) -> Self {
16037            Self {
16038                id: ::fidl_next::CompatFrom::compat_from(value.id),
16039
16040                item: ::fidl_next::CompatFrom::compat_from(value.item),
16041            }
16042        }
16043    }
16044
16045    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryGetRequest>
16046        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
16047    {
16048        #[inline]
16049        fn compat_from(value: crate::CapabilityStoreDictionaryGetRequest) -> Self {
16050            Self {
16051                id: ::fidl_next::CompatFrom::compat_from(value.id),
16052
16053                key: ::fidl_next::CompatFrom::compat_from(value.key),
16054
16055                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16056            }
16057        }
16058    }
16059
16060    impl
16061        ::fidl_next::CompatFrom<
16062            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
16063        > for crate::CapabilityStoreDictionaryGetRequest
16064    {
16065        #[inline]
16066        fn compat_from(
16067            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
16068        ) -> Self {
16069            Self {
16070                id: ::fidl_next::CompatFrom::compat_from(value.id),
16071
16072                key: ::fidl_next::CompatFrom::compat_from(value.key),
16073
16074                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16075            }
16076        }
16077    }
16078
16079    impl ::fidl_next::CompatFrom<crate::WrappedCapabilityId>
16080        for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
16081    {
16082        #[inline]
16083        fn compat_from(value: crate::WrappedCapabilityId) -> Self {
16084            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
16085        }
16086    }
16087
16088    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::WrappedCapabilityId>
16089        for crate::WrappedCapabilityId
16090    {
16091        #[inline]
16092        fn compat_from(value: ::fidl_fuchsia_component_sandbox::WrappedCapabilityId) -> Self {
16093            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
16094        }
16095    }
16096
16097    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryRemoveRequest>
16098        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
16099    {
16100        #[inline]
16101        fn compat_from(value: crate::CapabilityStoreDictionaryRemoveRequest) -> Self {
16102            Self {
16103                id: ::fidl_next::CompatFrom::compat_from(value.id),
16104
16105                key: ::fidl_next::CompatFrom::compat_from(value.key),
16106
16107                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16108            }
16109        }
16110    }
16111
16112    impl
16113        ::fidl_next::CompatFrom<
16114            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
16115        > for crate::CapabilityStoreDictionaryRemoveRequest
16116    {
16117        #[inline]
16118        fn compat_from(
16119            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
16120        ) -> Self {
16121            Self {
16122                id: ::fidl_next::CompatFrom::compat_from(value.id),
16123
16124                key: ::fidl_next::CompatFrom::compat_from(value.key),
16125
16126                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16127            }
16128        }
16129    }
16130
16131    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCopyRequest>
16132        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
16133    {
16134        #[inline]
16135        fn compat_from(value: crate::CapabilityStoreDictionaryCopyRequest) -> Self {
16136            Self {
16137                id: ::fidl_next::CompatFrom::compat_from(value.id),
16138
16139                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16140            }
16141        }
16142    }
16143
16144    impl
16145        ::fidl_next::CompatFrom<
16146            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
16147        > for crate::CapabilityStoreDictionaryCopyRequest
16148    {
16149        #[inline]
16150        fn compat_from(
16151            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
16152        ) -> Self {
16153            Self {
16154                id: ::fidl_next::CompatFrom::compat_from(value.id),
16155
16156                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
16157            }
16158        }
16159    }
16160
16161    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
16162        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
16163    {
16164        #[inline]
16165        fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
16166            Self {
16167                id: ::fidl_next::CompatFrom::compat_from(value.id),
16168
16169                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16170            }
16171        }
16172    }
16173
16174    impl
16175        ::fidl_next::CompatFrom<
16176            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
16177        > for crate::CapabilityStoreDictionaryKeysRequest
16178    {
16179        #[inline]
16180        fn compat_from(
16181            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
16182        ) -> Self {
16183            Self {
16184                id: ::fidl_next::CompatFrom::compat_from(value.id),
16185
16186                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16187            }
16188        }
16189    }
16190
16191    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
16192        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
16193    {
16194        #[inline]
16195        fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
16196            Self {
16197                id: ::fidl_next::CompatFrom::compat_from(value.id),
16198
16199                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16200            }
16201        }
16202    }
16203
16204    impl
16205        ::fidl_next::CompatFrom<
16206            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
16207        > for crate::CapabilityStoreDictionaryEnumerateRequest
16208    {
16209        #[inline]
16210        fn compat_from(
16211            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
16212        ) -> Self {
16213            Self {
16214                id: ::fidl_next::CompatFrom::compat_from(value.id),
16215
16216                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16217            }
16218        }
16219    }
16220
16221    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
16222        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
16223    {
16224        #[inline]
16225        fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
16226            Self {
16227                id: ::fidl_next::CompatFrom::compat_from(value.id),
16228
16229                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16230            }
16231        }
16232    }
16233
16234    impl
16235        ::fidl_next::CompatFrom<
16236            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
16237        > for crate::CapabilityStoreDictionaryDrainRequest
16238    {
16239        #[inline]
16240        fn compat_from(
16241            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
16242        ) -> Self {
16243            Self {
16244                id: ::fidl_next::CompatFrom::compat_from(value.id),
16245
16246                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
16247            }
16248        }
16249    }
16250
16251    impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
16252        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
16253    {
16254        #[inline]
16255        fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
16256            Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
16257        }
16258    }
16259
16260    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
16261        for crate::CapabilityStoreExportResponse
16262    {
16263        #[inline]
16264        fn compat_from(
16265            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
16266        ) -> Self {
16267            Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
16268        }
16269    }
16270
16271    impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
16272        for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
16273    {
16274        #[inline]
16275        fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
16276            Self {
16277                id: ::fidl_next::CompatFrom::compat_from(value.id),
16278
16279                capability: ::fidl_next::CompatFrom::compat_from(value.capability),
16280            }
16281        }
16282    }
16283
16284    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
16285        for crate::CapabilityStoreImportRequest
16286    {
16287        #[inline]
16288        fn compat_from(
16289            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
16290        ) -> Self {
16291            Self {
16292                id: ::fidl_next::CompatFrom::compat_from(value.id),
16293
16294                capability: ::fidl_next::CompatFrom::compat_from(value.capability),
16295            }
16296        }
16297    }
16298
16299    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
16300        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
16301    {
16302        #[inline]
16303        fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
16304            Self {
16305                id: ::fidl_next::CompatFrom::compat_from(value.id),
16306
16307                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
16308            }
16309        }
16310    }
16311
16312    impl
16313        ::fidl_next::CompatFrom<
16314            ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
16315        > for crate::CapabilityStoreDirConnectorCreateRequest
16316    {
16317        #[inline]
16318        fn compat_from(
16319            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
16320        ) -> Self {
16321            Self {
16322                id: ::fidl_next::CompatFrom::compat_from(value.id),
16323
16324                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
16325            }
16326        }
16327    }
16328
16329    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
16330        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
16331    {
16332        #[inline]
16333        fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
16334            Self {
16335                id: ::fidl_next::CompatFrom::compat_from(value.id),
16336
16337                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
16338            }
16339        }
16340    }
16341
16342    impl
16343        ::fidl_next::CompatFrom<
16344            ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
16345        > for crate::CapabilityStoreDirConnectorOpenRequest
16346    {
16347        #[inline]
16348        fn compat_from(
16349            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
16350        ) -> Self {
16351            Self {
16352                id: ::fidl_next::CompatFrom::compat_from(value.id),
16353
16354                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
16355            }
16356        }
16357    }
16358
16359    #[cfg(target_os = "fuchsia")]
16360    /// An alias for a client over `zx::Channel` for the `CapabilityStore`
16361    /// protocol.
16362    pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
16363
16364    impl ::fidl_next::CompatFrom<crate::CapabilityStore>
16365        for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
16366    {
16367        fn compat_from(_: crate::CapabilityStore) -> Self {
16368            Self
16369        }
16370    }
16371
16372    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
16373        for crate::CapabilityStore
16374    {
16375        fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
16376            Self
16377        }
16378    }
16379
16380    #[cfg(target_os = "fuchsia")]
16381
16382    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
16383        for crate::CapabilityStore
16384    {
16385        fn client_compat_from(
16386            proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
16387        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16388            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16389            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16390            ::fidl_next::ClientDispatcher::new(client_end)
16391        }
16392    }
16393
16394    impl ::fidl_next::CompatFrom<crate::InstanceToken>
16395        for ::fidl_fuchsia_component_sandbox::InstanceToken
16396    {
16397        #[inline]
16398        fn compat_from(value: crate::InstanceToken) -> Self {
16399            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
16400        }
16401    }
16402
16403    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
16404        for crate::InstanceToken
16405    {
16406        #[inline]
16407        fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
16408            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
16409        }
16410    }
16411
16412    impl ::fidl_next::CompatFrom<crate::RouteRequest>
16413        for ::fidl_fuchsia_component_sandbox::RouteRequest
16414    {
16415        fn compat_from(value: crate::RouteRequest) -> Self {
16416            Self {
16417                requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
16418
16419                metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
16420
16421                __source_breaking: ::fidl::marker::SourceBreaking,
16422            }
16423        }
16424    }
16425
16426    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
16427        for crate::RouteRequest
16428    {
16429        fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
16430            Self {
16431                requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
16432
16433                metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
16434            }
16435        }
16436    }
16437
16438    impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
16439        for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
16440    {
16441        fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
16442            match value {
16443                crate::ConnectorRouterRouteResponse::Connector(value) => {
16444                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
16445                }
16446
16447                crate::ConnectorRouterRouteResponse::Unavailable(value) => {
16448                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16449                }
16450            }
16451        }
16452    }
16453
16454    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
16455        for crate::ConnectorRouterRouteResponse
16456    {
16457        fn compat_from(
16458            value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
16459        ) -> Self {
16460            match value {
16461                ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
16462                    value,
16463                ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
16464
16465                ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
16466                    value,
16467                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
16468            }
16469        }
16470    }
16471
16472    impl ::fidl_next::CompatFrom<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
16473        fn compat_from(value: crate::RouterError) -> Self {
16474            match value {
16475                crate::RouterError::NotFound => Self::NotFound,
16476
16477                crate::RouterError::InvalidArgs => Self::InvalidArgs,
16478
16479                crate::RouterError::NotSupported => Self::NotSupported,
16480
16481                crate::RouterError::Internal => Self::Internal,
16482
16483                crate::RouterError::UnknownOrdinal_(unknown_ordinal) => {
16484                    Self::__SourceBreaking { unknown_ordinal }
16485                }
16486            }
16487        }
16488    }
16489
16490    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouterError> for crate::RouterError {
16491        fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouterError) -> Self {
16492            match value {
16493                ::fidl_fuchsia_component_sandbox::RouterError::NotFound => Self::NotFound,
16494
16495                ::fidl_fuchsia_component_sandbox::RouterError::InvalidArgs => Self::InvalidArgs,
16496
16497                ::fidl_fuchsia_component_sandbox::RouterError::NotSupported => Self::NotSupported,
16498
16499                ::fidl_fuchsia_component_sandbox::RouterError::Internal => Self::Internal,
16500
16501                ::fidl_fuchsia_component_sandbox::RouterError::__SourceBreaking {
16502                    unknown_ordinal: value,
16503                } => Self::UnknownOrdinal_(value),
16504            }
16505        }
16506    }
16507
16508    #[cfg(target_os = "fuchsia")]
16509    /// An alias for a client over `zx::Channel` for the `ConnectorRouter`
16510    /// protocol.
16511    pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
16512
16513    impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
16514        for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
16515    {
16516        fn compat_from(_: crate::ConnectorRouter) -> Self {
16517            Self
16518        }
16519    }
16520
16521    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
16522        for crate::ConnectorRouter
16523    {
16524        fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
16525            Self
16526        }
16527    }
16528
16529    #[cfg(target_os = "fuchsia")]
16530
16531    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
16532        for crate::ConnectorRouter
16533    {
16534        fn client_compat_from(
16535            proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
16536        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16537            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16538            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16539            ::fidl_next::ClientDispatcher::new(client_end)
16540        }
16541    }
16542
16543    impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
16544        for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
16545    {
16546        fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
16547            match value {
16548                crate::DataRouterRouteResponse::Data(value) => {
16549                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
16550                }
16551
16552                crate::DataRouterRouteResponse::Unavailable(value) => {
16553                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16554                }
16555            }
16556        }
16557    }
16558
16559    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
16560        for crate::DataRouterRouteResponse
16561    {
16562        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
16563            match value {
16564                ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
16565                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
16566                }
16567
16568                ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
16569                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16570                }
16571            }
16572        }
16573    }
16574
16575    #[cfg(target_os = "fuchsia")]
16576    /// An alias for a client over `zx::Channel` for the `DataRouter`
16577    /// protocol.
16578    pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
16579
16580    impl ::fidl_next::CompatFrom<crate::DataRouter>
16581        for ::fidl_fuchsia_component_sandbox::DataRouterMarker
16582    {
16583        fn compat_from(_: crate::DataRouter) -> Self {
16584            Self
16585        }
16586    }
16587
16588    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
16589        for crate::DataRouter
16590    {
16591        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
16592            Self
16593        }
16594    }
16595
16596    #[cfg(target_os = "fuchsia")]
16597
16598    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
16599        for crate::DataRouter
16600    {
16601        fn client_compat_from(
16602            proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
16603        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16604            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16605            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16606            ::fidl_next::ClientDispatcher::new(client_end)
16607        }
16608    }
16609
16610    #[cfg(target_os = "fuchsia")]
16611    /// An alias for a client over `zx::Channel` for the `Dictionary`
16612    /// protocol.
16613    pub type DictionaryProxy = ::fidl_next::Client<crate::Dictionary>;
16614
16615    impl ::fidl_next::CompatFrom<crate::Dictionary>
16616        for ::fidl_fuchsia_component_sandbox::DictionaryMarker
16617    {
16618        fn compat_from(_: crate::Dictionary) -> Self {
16619            Self
16620        }
16621    }
16622
16623    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryMarker>
16624        for crate::Dictionary
16625    {
16626        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryMarker) -> Self {
16627            Self
16628        }
16629    }
16630
16631    #[cfg(target_os = "fuchsia")]
16632
16633    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryProxy>
16634        for crate::Dictionary
16635    {
16636        fn client_compat_from(
16637            proxy: ::fidl_fuchsia_component_sandbox::DictionaryProxy,
16638        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16639            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16640            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16641            ::fidl_next::ClientDispatcher::new(client_end)
16642        }
16643    }
16644
16645    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextRequest>
16646        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
16647    {
16648        #[inline]
16649        fn compat_from(value: crate::DictionaryDrainIteratorGetNextRequest) -> Self {
16650            Self {
16651                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16652
16653                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16654            }
16655        }
16656    }
16657
16658    impl
16659        ::fidl_next::CompatFrom<
16660            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
16661        > for crate::DictionaryDrainIteratorGetNextRequest
16662    {
16663        #[inline]
16664        fn compat_from(
16665            value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
16666        ) -> Self {
16667            Self {
16668                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16669
16670                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16671            }
16672        }
16673    }
16674
16675    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
16676        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
16677    {
16678        #[inline]
16679        fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
16680            Self {
16681                items: ::fidl_next::CompatFrom::compat_from(value.items),
16682
16683                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16684            }
16685        }
16686    }
16687
16688    impl
16689        ::fidl_next::CompatFrom<
16690            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
16691        > for crate::DictionaryDrainIteratorGetNextResponse
16692    {
16693        #[inline]
16694        fn compat_from(
16695            value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
16696        ) -> Self {
16697            Self {
16698                items: ::fidl_next::CompatFrom::compat_from(value.items),
16699
16700                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16701            }
16702        }
16703    }
16704
16705    #[cfg(target_os = "fuchsia")]
16706    /// An alias for a client over `zx::Channel` for the `DictionaryDrainIterator`
16707    /// protocol.
16708    pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
16709
16710    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
16711        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
16712    {
16713        fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
16714            Self
16715        }
16716    }
16717
16718    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
16719        for crate::DictionaryDrainIterator
16720    {
16721        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
16722            Self
16723        }
16724    }
16725
16726    #[cfg(target_os = "fuchsia")]
16727
16728    impl
16729        ::fidl_next::ClientCompatFrom<
16730            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
16731        > for crate::DictionaryDrainIterator
16732    {
16733        fn client_compat_from(
16734            proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
16735        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16736            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16737            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16738            ::fidl_next::ClientDispatcher::new(client_end)
16739        }
16740    }
16741
16742    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextRequest>
16743        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
16744    {
16745        #[inline]
16746        fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextRequest) -> Self {
16747            Self {
16748                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16749
16750                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16751            }
16752        }
16753    }
16754
16755    impl
16756        ::fidl_next::CompatFrom<
16757            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
16758        > for crate::DictionaryEnumerateIteratorGetNextRequest
16759    {
16760        #[inline]
16761        fn compat_from(
16762            value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
16763        ) -> Self {
16764            Self {
16765                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
16766
16767                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
16768            }
16769        }
16770    }
16771
16772    impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
16773        for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
16774    {
16775        #[inline]
16776        fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
16777            Self {
16778                key: ::fidl_next::CompatFrom::compat_from(value.key),
16779
16780                value: ::fidl_next::CompatFrom::compat_from(value.value),
16781            }
16782        }
16783    }
16784
16785    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
16786        for crate::DictionaryOptionalItem
16787    {
16788        #[inline]
16789        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
16790            Self {
16791                key: ::fidl_next::CompatFrom::compat_from(value.key),
16792
16793                value: ::fidl_next::CompatFrom::compat_from(value.value),
16794            }
16795        }
16796    }
16797
16798    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
16799        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
16800    {
16801        #[inline]
16802        fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
16803            Self {
16804                items: ::fidl_next::CompatFrom::compat_from(value.items),
16805
16806                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16807            }
16808        }
16809    }
16810
16811    impl
16812        ::fidl_next::CompatFrom<
16813            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
16814        > for crate::DictionaryEnumerateIteratorGetNextResponse
16815    {
16816        #[inline]
16817        fn compat_from(
16818            value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
16819        ) -> Self {
16820            Self {
16821                items: ::fidl_next::CompatFrom::compat_from(value.items),
16822
16823                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
16824            }
16825        }
16826    }
16827
16828    #[cfg(target_os = "fuchsia")]
16829    /// An alias for a client over `zx::Channel` for the `DictionaryEnumerateIterator`
16830    /// protocol.
16831    pub type DictionaryEnumerateIteratorProxy =
16832        ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
16833
16834    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
16835        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
16836    {
16837        fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
16838            Self
16839        }
16840    }
16841
16842    impl
16843        ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
16844        for crate::DictionaryEnumerateIterator
16845    {
16846        fn compat_from(
16847            _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
16848        ) -> Self {
16849            Self
16850        }
16851    }
16852
16853    #[cfg(target_os = "fuchsia")]
16854
16855    impl
16856        ::fidl_next::ClientCompatFrom<
16857            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
16858        > for crate::DictionaryEnumerateIterator
16859    {
16860        fn client_compat_from(
16861            proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
16862        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16863            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16864            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16865            ::fidl_next::ClientDispatcher::new(client_end)
16866        }
16867    }
16868
16869    impl ::fidl_next::CompatFrom<crate::DictionaryError>
16870        for ::fidl_fuchsia_component_sandbox::DictionaryError
16871    {
16872        fn compat_from(value: crate::DictionaryError) -> Self {
16873            match value {
16874                crate::DictionaryError::NotFound => Self::NotFound,
16875
16876                crate::DictionaryError::AlreadyExists => Self::AlreadyExists,
16877
16878                crate::DictionaryError::BadCapability => Self::BadCapability,
16879
16880                crate::DictionaryError::InvalidKey => Self::InvalidKey,
16881
16882                crate::DictionaryError::NotCloneable => Self::NotCloneable,
16883
16884                crate::DictionaryError::UnknownOrdinal_(unknown_ordinal) => {
16885                    Self::__SourceBreaking { unknown_ordinal }
16886                }
16887            }
16888        }
16889    }
16890
16891    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryError>
16892        for crate::DictionaryError
16893    {
16894        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryError) -> Self {
16895            match value {
16896                ::fidl_fuchsia_component_sandbox::DictionaryError::NotFound => Self::NotFound,
16897
16898                ::fidl_fuchsia_component_sandbox::DictionaryError::AlreadyExists => {
16899                    Self::AlreadyExists
16900                }
16901
16902                ::fidl_fuchsia_component_sandbox::DictionaryError::BadCapability => {
16903                    Self::BadCapability
16904                }
16905
16906                ::fidl_fuchsia_component_sandbox::DictionaryError::InvalidKey => Self::InvalidKey,
16907
16908                ::fidl_fuchsia_component_sandbox::DictionaryError::NotCloneable => {
16909                    Self::NotCloneable
16910                }
16911
16912                ::fidl_fuchsia_component_sandbox::DictionaryError::__SourceBreaking {
16913                    unknown_ordinal: value,
16914                } => Self::UnknownOrdinal_(value),
16915            }
16916        }
16917    }
16918
16919    impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
16920        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
16921    {
16922        #[inline]
16923        fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
16924            Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
16925        }
16926    }
16927
16928    impl
16929        ::fidl_next::CompatFrom<
16930            ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
16931        > for crate::DictionaryKeysIteratorGetNextResponse
16932    {
16933        #[inline]
16934        fn compat_from(
16935            value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
16936        ) -> Self {
16937            Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
16938        }
16939    }
16940
16941    #[cfg(target_os = "fuchsia")]
16942    /// An alias for a client over `zx::Channel` for the `DictionaryKeysIterator`
16943    /// protocol.
16944    pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
16945
16946    impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
16947        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
16948    {
16949        fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
16950            Self
16951        }
16952    }
16953
16954    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
16955        for crate::DictionaryKeysIterator
16956    {
16957        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
16958            Self
16959        }
16960    }
16961
16962    #[cfg(target_os = "fuchsia")]
16963
16964    impl
16965        ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
16966        for crate::DictionaryKeysIterator
16967    {
16968        fn client_compat_from(
16969            proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
16970        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
16971            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
16972            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
16973            ::fidl_next::ClientDispatcher::new(client_end)
16974        }
16975    }
16976
16977    impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
16978        for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
16979    {
16980        fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
16981            match value {
16982                crate::DictionaryRouterRouteResponse::Dictionary(value) => {
16983                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
16984                }
16985
16986                crate::DictionaryRouterRouteResponse::Unavailable(value) => {
16987                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
16988                }
16989            }
16990        }
16991    }
16992
16993    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
16994        for crate::DictionaryRouterRouteResponse
16995    {
16996        fn compat_from(
16997            value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
16998        ) -> Self {
16999            match value {
17000                ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
17001                    value,
17002                ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
17003
17004                ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
17005                    value,
17006                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17007            }
17008        }
17009    }
17010
17011    #[cfg(target_os = "fuchsia")]
17012    /// An alias for a client over `zx::Channel` for the `DictionaryRouter`
17013    /// protocol.
17014    pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
17015
17016    impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
17017        for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
17018    {
17019        fn compat_from(_: crate::DictionaryRouter) -> Self {
17020            Self
17021        }
17022    }
17023
17024    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
17025        for crate::DictionaryRouter
17026    {
17027        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
17028            Self
17029        }
17030    }
17031
17032    #[cfg(target_os = "fuchsia")]
17033
17034    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
17035        for crate::DictionaryRouter
17036    {
17037        fn client_compat_from(
17038            proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
17039        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17040            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17041            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17042            ::fidl_next::ClientDispatcher::new(client_end)
17043        }
17044    }
17045
17046    impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
17047        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
17048    {
17049        fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
17050            match value {
17051                crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
17052                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
17053                }
17054
17055                crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
17056                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17057                }
17058            }
17059        }
17060    }
17061
17062    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
17063        for crate::DirConnectorRouterRouteResponse
17064    {
17065        fn compat_from(
17066            value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
17067        ) -> Self {
17068            match value {
17069                ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
17070                    value,
17071                ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
17072
17073                ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
17074                    value,
17075                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17076            }
17077        }
17078    }
17079
17080    #[cfg(target_os = "fuchsia")]
17081    /// An alias for a client over `zx::Channel` for the `DirConnectorRouter`
17082    /// protocol.
17083    pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
17084
17085    impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
17086        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
17087    {
17088        fn compat_from(_: crate::DirConnectorRouter) -> Self {
17089            Self
17090        }
17091    }
17092
17093    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
17094        for crate::DirConnectorRouter
17095    {
17096        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
17097            Self
17098        }
17099    }
17100
17101    #[cfg(target_os = "fuchsia")]
17102
17103    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
17104        for crate::DirConnectorRouter
17105    {
17106        fn client_compat_from(
17107            proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
17108        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17109            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17110            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17111            ::fidl_next::ClientDispatcher::new(client_end)
17112        }
17113    }
17114
17115    impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
17116        for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
17117    {
17118        fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
17119            match value {
17120                crate::DirEntryRouterRouteResponse::DirEntry(value) => {
17121                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
17122                }
17123
17124                crate::DirEntryRouterRouteResponse::Unavailable(value) => {
17125                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17126                }
17127            }
17128        }
17129    }
17130
17131    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
17132        for crate::DirEntryRouterRouteResponse
17133    {
17134        fn compat_from(
17135            value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
17136        ) -> Self {
17137            match value {
17138                ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
17139                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
17140                }
17141
17142                ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
17143                    value,
17144                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17145            }
17146        }
17147    }
17148
17149    #[cfg(target_os = "fuchsia")]
17150    /// An alias for a client over `zx::Channel` for the `DirEntryRouter`
17151    /// protocol.
17152    pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
17153
17154    impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
17155        for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
17156    {
17157        fn compat_from(_: crate::DirEntryRouter) -> Self {
17158            Self
17159        }
17160    }
17161
17162    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
17163        for crate::DirEntryRouter
17164    {
17165        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
17166            Self
17167        }
17168    }
17169
17170    #[cfg(target_os = "fuchsia")]
17171
17172    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
17173        for crate::DirEntryRouter
17174    {
17175        fn client_compat_from(
17176            proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
17177        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17178            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17179            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17180            ::fidl_next::ClientDispatcher::new(client_end)
17181        }
17182    }
17183
17184    impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
17185        for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
17186    {
17187        #[inline]
17188        fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
17189            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17190        }
17191    }
17192
17193    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
17194        for crate::DirReceiverReceiveRequest
17195    {
17196        #[inline]
17197        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
17198            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17199        }
17200    }
17201
17202    #[cfg(target_os = "fuchsia")]
17203    /// An alias for a client over `zx::Channel` for the `DirReceiver`
17204    /// protocol.
17205    pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
17206
17207    impl ::fidl_next::CompatFrom<crate::DirReceiver>
17208        for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
17209    {
17210        fn compat_from(_: crate::DirReceiver) -> Self {
17211            Self
17212        }
17213    }
17214
17215    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
17216        for crate::DirReceiver
17217    {
17218        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
17219            Self
17220        }
17221    }
17222
17223    #[cfg(target_os = "fuchsia")]
17224
17225    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
17226        for crate::DirReceiver
17227    {
17228        fn client_compat_from(
17229            proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
17230        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17231            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17232            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17233            ::fidl_next::ClientDispatcher::new(client_end)
17234        }
17235    }
17236
17237    impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
17238        for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
17239    {
17240        fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
17241            match value {
17242                crate::DirectoryRouterRouteResponse::Directory(value) => {
17243                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
17244                }
17245
17246                crate::DirectoryRouterRouteResponse::Unavailable(value) => {
17247                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
17248                }
17249            }
17250        }
17251    }
17252
17253    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
17254        for crate::DirectoryRouterRouteResponse
17255    {
17256        fn compat_from(
17257            value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
17258        ) -> Self {
17259            match value {
17260                ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
17261                    value,
17262                ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
17263
17264                ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
17265                    value,
17266                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
17267            }
17268        }
17269    }
17270
17271    #[cfg(target_os = "fuchsia")]
17272    /// An alias for a client over `zx::Channel` for the `DirectoryRouter`
17273    /// protocol.
17274    pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
17275
17276    impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
17277        for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
17278    {
17279        fn compat_from(_: crate::DirectoryRouter) -> Self {
17280            Self
17281        }
17282    }
17283
17284    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
17285        for crate::DirectoryRouter
17286    {
17287        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
17288            Self
17289        }
17290    }
17291
17292    #[cfg(target_os = "fuchsia")]
17293
17294    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
17295        for crate::DirectoryRouter
17296    {
17297        fn client_compat_from(
17298            proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
17299        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17300            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17301            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17302            ::fidl_next::ClientDispatcher::new(client_end)
17303        }
17304    }
17305
17306    impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
17307        for ::fidl_fuchsia_component_sandbox::ProtocolPayload
17308    {
17309        #[inline]
17310        fn compat_from(value: crate::ProtocolPayload) -> Self {
17311            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17312        }
17313    }
17314
17315    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
17316        for crate::ProtocolPayload
17317    {
17318        #[inline]
17319        fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
17320            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
17321        }
17322    }
17323
17324    #[cfg(target_os = "fuchsia")]
17325    /// An alias for a client over `zx::Channel` for the `Receiver`
17326    /// protocol.
17327    pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
17328
17329    impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
17330        fn compat_from(_: crate::Receiver) -> Self {
17331            Self
17332        }
17333    }
17334
17335    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
17336        fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
17337            Self
17338        }
17339    }
17340
17341    #[cfg(target_os = "fuchsia")]
17342
17343    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
17344        for crate::Receiver
17345    {
17346        fn client_compat_from(
17347            proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
17348        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
17349            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
17350            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
17351            ::fidl_next::ClientDispatcher::new(client_end)
17352        }
17353    }
17354
17355    impl ::fidl_next::CompatFrom<crate::Unavailable> for ::fidl_fuchsia_component_sandbox::Unavailable {
17356        #[inline]
17357        fn compat_from(value: crate::Unavailable) -> Self {
17358            Self {}
17359        }
17360    }
17361
17362    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unavailable> for crate::Unavailable {
17363        #[inline]
17364        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unavailable) -> Self {
17365            Self {}
17366        }
17367    }
17368}