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
5pub mod natural {
6
7    #[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"]
8    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9    #[repr(u32)]
10    pub enum Availability {
11        Required = 1,
12        Optional = 2,
13        SameAsTarget = 3,
14        Transitional = 4,
15    }
16
17    impl ::fidl_next::Encodable for Availability {
18        type Encoded = crate::wire::Availability;
19    }
20    impl ::core::convert::TryFrom<u32> for Availability {
21        type Error = ::fidl_next::UnknownStrictEnumMemberError;
22        fn try_from(
23            value: u32,
24        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
25            match value {
26                1 => Ok(Self::Required),
27                2 => Ok(Self::Optional),
28                3 => Ok(Self::SameAsTarget),
29                4 => Ok(Self::Transitional),
30
31                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
32            }
33        }
34    }
35
36    unsafe impl<___E> ::fidl_next::Encode<___E> for Availability
37    where
38        ___E: ?Sized,
39    {
40        #[inline]
41        fn encode(
42            self,
43            encoder: &mut ___E,
44            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
45            _: (),
46        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
47            ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
48        }
49    }
50
51    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Availability
52    where
53        ___E: ?Sized,
54    {
55        #[inline]
56        fn encode_ref(
57            &self,
58            encoder: &mut ___E,
59            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
60            _: (),
61        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
62            ::fidl_next::munge!(let crate::wire::Availability { value } = out);
63            let _ = value.write(::fidl_next::WireU32::from(match *self {
64                Self::Required => 1,
65
66                Self::Optional => 2,
67
68                Self::SameAsTarget => 3,
69
70                Self::Transitional => 4,
71            }));
72
73            Ok(())
74        }
75    }
76
77    impl ::core::convert::From<crate::wire::Availability> for Availability {
78        fn from(wire: crate::wire::Availability) -> Self {
79            match u32::from(wire.value) {
80                1 => Self::Required,
81
82                2 => Self::Optional,
83
84                3 => Self::SameAsTarget,
85
86                4 => Self::Transitional,
87
88                _ => unsafe { ::core::hint::unreachable_unchecked() },
89            }
90        }
91    }
92
93    impl ::fidl_next::FromWire<crate::wire::Availability> for Availability {
94        #[inline]
95        fn from_wire(wire: crate::wire::Availability) -> Self {
96            Self::from(wire)
97        }
98    }
99
100    impl ::fidl_next::FromWireRef<crate::wire::Availability> for Availability {
101        #[inline]
102        fn from_wire_ref(wire: &crate::wire::Availability) -> Self {
103            Self::from(*wire)
104        }
105    }
106
107    #[derive(PartialEq, Clone, Debug)]
108    #[repr(C)]
109    pub struct Unit {}
110
111    impl ::fidl_next::Encodable for Unit {
112        type Encoded = crate::wire::Unit;
113    }
114
115    unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
116    where
117        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
118    {
119        #[inline]
120        fn encode(
121            self,
122            encoder_: &mut ___E,
123            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
124            _: (),
125        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
126            *out_ = ::core::mem::MaybeUninit::zeroed();
127
128            Ok(())
129        }
130    }
131
132    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unit
133    where
134        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
135    {
136        #[inline]
137        fn encode_ref(
138            &self,
139            encoder_: &mut ___E,
140            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
141            _: (),
142        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
143            ::fidl_next::munge! {
144                let Self::Encoded {
145
146                        _empty,
147
148
149                } = out_;
150            }
151
152            Ok(())
153        }
154    }
155
156    impl ::fidl_next::EncodableOption for Unit {
157        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Unit>;
158    }
159
160    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unit
161    where
162        ___E: ::fidl_next::Encoder + ?Sized,
163        Unit: ::fidl_next::Encode<___E>,
164    {
165        #[inline]
166        fn encode_option(
167            this: ::core::option::Option<Self>,
168            encoder: &mut ___E,
169            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
170            _: (),
171        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
172            if let Some(inner) = this {
173                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
174                ::fidl_next::WireBox::encode_present(out);
175            } else {
176                ::fidl_next::WireBox::encode_absent(out);
177            }
178
179            Ok(())
180        }
181    }
182
183    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unit
184    where
185        ___E: ::fidl_next::Encoder + ?Sized,
186        Unit: ::fidl_next::EncodeRef<___E>,
187    {
188        #[inline]
189        fn encode_option_ref(
190            this: ::core::option::Option<&Self>,
191            encoder: &mut ___E,
192            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
193            _: (),
194        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
195            if let Some(inner) = this {
196                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
197                ::fidl_next::WireBox::encode_present(out);
198            } else {
199                ::fidl_next::WireBox::encode_absent(out);
200            }
201
202            Ok(())
203        }
204    }
205
206    impl ::fidl_next::FromWire<crate::wire::Unit> for Unit {
207        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unit, Self> =
208            unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
209
210        #[inline]
211        fn from_wire(wire: crate::wire::Unit) -> Self {
212            Self {}
213        }
214    }
215
216    impl ::fidl_next::FromWireRef<crate::wire::Unit> for Unit {
217        #[inline]
218        fn from_wire_ref(wire: &crate::wire::Unit) -> Self {
219            Self {}
220        }
221    }
222
223    #[derive(PartialEq, Clone, Debug)]
224    pub enum Data {
225        Bytes(::std::vec::Vec<u8>),
226
227        String(::std::string::String),
228
229        Int64(i64),
230
231        Uint64(u64),
232
233        UnknownOrdinal_(u64),
234    }
235
236    impl Data {
237        pub fn is_unknown(&self) -> bool {
238            #[allow(unreachable_patterns)]
239            match self {
240                Self::UnknownOrdinal_(_) => true,
241                _ => false,
242            }
243        }
244    }
245
246    impl ::fidl_next::Encodable for Data {
247        type Encoded = crate::wire::Data<'static>;
248    }
249
250    unsafe impl<___E> ::fidl_next::Encode<___E> for Data
251    where
252        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
253        ___E: ::fidl_next::Encoder,
254    {
255        #[inline]
256        fn encode(
257            self,
258            encoder: &mut ___E,
259            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
260            _: (),
261        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
262            ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
263
264            match self {
265                Self::Bytes(value) => ::fidl_next::RawWireUnion::encode_as::<
266                    ___E,
267                    ::std::vec::Vec<u8>,
268                >(value, 1, encoder, raw, (8192, ()))?,
269
270                Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
271                    ___E,
272                    ::std::string::String,
273                >(value, 2, encoder, raw, 8192)?,
274
275                Self::Int64(value) => {
276                    ::fidl_next::RawWireUnion::encode_as::<___E, i64>(value, 3, encoder, raw, ())?
277                }
278
279                Self::Uint64(value) => {
280                    ::fidl_next::RawWireUnion::encode_as::<___E, u64>(value, 4, encoder, raw, ())?
281                }
282
283                Self::UnknownOrdinal_(ordinal) => {
284                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
285                }
286            }
287
288            Ok(())
289        }
290    }
291
292    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Data
293    where
294        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
295        ___E: ::fidl_next::Encoder,
296    {
297        #[inline]
298        fn encode_ref(
299            &self,
300            encoder: &mut ___E,
301            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
302            _: (),
303        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
304            ::fidl_next::munge!(let crate::wire::Data { raw, _phantom: _ } = out);
305
306            match self {
307                Self::Bytes(value) => ::fidl_next::RawWireUnion::encode_as::<
308                    ___E,
309                    &::std::vec::Vec<u8>,
310                >(value, 1, encoder, raw, (8192, ()))?,
311
312                Self::String(value) => ::fidl_next::RawWireUnion::encode_as::<
313                    ___E,
314                    &::std::string::String,
315                >(value, 2, encoder, raw, 8192)?,
316
317                Self::Int64(value) => {
318                    ::fidl_next::RawWireUnion::encode_as::<___E, &i64>(value, 3, encoder, raw, ())?
319                }
320
321                Self::Uint64(value) => {
322                    ::fidl_next::RawWireUnion::encode_as::<___E, &u64>(value, 4, encoder, raw, ())?
323                }
324
325                Self::UnknownOrdinal_(ordinal) => {
326                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
327                }
328            }
329
330            Ok(())
331        }
332    }
333
334    impl ::fidl_next::EncodableOption for Data {
335        type EncodedOption = crate::wire_optional::Data<'static>;
336    }
337
338    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Data
339    where
340        ___E: ?Sized,
341        Data: ::fidl_next::Encode<___E>,
342    {
343        #[inline]
344        fn encode_option(
345            this: ::core::option::Option<Self>,
346            encoder: &mut ___E,
347            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
348            _: (),
349        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
350            ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
351
352            if let Some(inner) = this {
353                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
354                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
355            } else {
356                ::fidl_next::RawWireUnion::encode_absent(raw);
357            }
358
359            Ok(())
360        }
361    }
362
363    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Data
364    where
365        ___E: ?Sized,
366        Data: ::fidl_next::EncodeRef<___E>,
367    {
368        #[inline]
369        fn encode_option_ref(
370            this: ::core::option::Option<&Self>,
371            encoder: &mut ___E,
372            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
373            _: (),
374        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
375            ::fidl_next::munge!(let crate::wire_optional::Data { raw, _phantom: _ } = &mut *out);
376
377            if let Some(inner) = this {
378                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
379                ::fidl_next::EncodeRef::encode_ref(inner, encoder, value_out, ())?;
380            } else {
381                ::fidl_next::RawWireUnion::encode_absent(raw);
382            }
383
384            Ok(())
385        }
386    }
387
388    impl<'de> ::fidl_next::FromWire<crate::wire::Data<'de>> for Data {
389        #[inline]
390        fn from_wire(wire: crate::wire::Data<'de>) -> Self {
391            let wire = ::core::mem::ManuallyDrop::new(wire);
392            match wire.raw.ordinal() {
393                1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
394                    wire.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
395                })),
396
397                2 => Self::String(::fidl_next::FromWire::from_wire(unsafe {
398                    wire.raw.get().read_unchecked::<::fidl_next::WireString<'de>>()
399                })),
400
401                3 => Self::Int64(::fidl_next::FromWire::from_wire(unsafe {
402                    wire.raw.get().read_unchecked::<::fidl_next::WireI64>()
403                })),
404
405                4 => Self::Uint64(::fidl_next::FromWire::from_wire(unsafe {
406                    wire.raw.get().read_unchecked::<::fidl_next::WireU64>()
407                })),
408
409                ord => return Self::UnknownOrdinal_(ord as u64),
410            }
411        }
412    }
413
414    impl<'de> ::fidl_next::FromWireRef<crate::wire::Data<'de>> for Data {
415        #[inline]
416        fn from_wire_ref(wire: &crate::wire::Data<'de>) -> Self {
417            match wire.raw.ordinal() {
418                1 => Self::Bytes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
419                    wire.raw.get().deref_unchecked::<::fidl_next::WireVector<'de, u8>>()
420                })),
421
422                2 => Self::String(::fidl_next::FromWireRef::from_wire_ref(unsafe {
423                    wire.raw.get().deref_unchecked::<::fidl_next::WireString<'de>>()
424                })),
425
426                3 => Self::Int64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
427                    wire.raw.get().deref_unchecked::<::fidl_next::WireI64>()
428                })),
429
430                4 => Self::Uint64(::fidl_next::FromWireRef::from_wire_ref(unsafe {
431                    wire.raw.get().deref_unchecked::<::fidl_next::WireU64>()
432                })),
433
434                ord => return Self::UnknownOrdinal_(ord as u64),
435            }
436        }
437    }
438
439    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Data {
440        #[inline]
441        fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
442            if let Some(inner) = wire.into_option() {
443                Some(::fidl_next::FromWire::from_wire(inner))
444            } else {
445                None
446            }
447        }
448    }
449
450    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>> for Box<Data> {
451        #[inline]
452        fn from_wire_option(wire: crate::wire_optional::Data<'de>) -> ::core::option::Option<Self> {
453            <
454            Data as ::fidl_next::FromWireOption<crate::wire_optional::Data<'de>>
455        >::from_wire_option(wire).map(Box::new)
456        }
457    }
458
459    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::Data<'de>> for Box<Data> {
460        #[inline]
461        fn from_wire_option_ref(
462            wire: &crate::wire_optional::Data<'de>,
463        ) -> ::core::option::Option<Self> {
464            if let Some(inner) = wire.as_ref() {
465                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
466            } else {
467                None
468            }
469        }
470    }
471
472    #[doc = " A token represents a bedrock object. Tokens are reference counted, dropping\n all counts of the token removes the object.\n"]
473    pub type Token = ::fidl_next::fuchsia::zx::EventPair;
474
475    #[derive(PartialEq, Debug)]
476    #[repr(C)]
477    pub struct DictionaryRef {
478        pub token: ::fidl_next::fuchsia::zx::EventPair,
479    }
480
481    impl ::fidl_next::Encodable for DictionaryRef {
482        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DictionaryRef> = unsafe {
483            ::fidl_next::CopyOptimization::enable_if(
484            true
485
486                && <
487                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
488                >::COPY_OPTIMIZATION.is_enabled()
489
490        )
491        };
492
493        type Encoded = crate::wire::DictionaryRef;
494    }
495
496    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRef
497    where
498        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
499        ___E: ::fidl_next::fuchsia::HandleEncoder,
500    {
501        #[inline]
502        fn encode(
503            self,
504            encoder_: &mut ___E,
505            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
506            _: (),
507        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
508            ::fidl_next::munge! {
509                let Self::Encoded {
510                    token,
511
512                } = out_;
513            }
514
515            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
516
517            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
518
519            Ok(())
520        }
521    }
522
523    impl ::fidl_next::EncodableOption for DictionaryRef {
524        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DictionaryRef>;
525    }
526
527    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRef
528    where
529        ___E: ::fidl_next::Encoder + ?Sized,
530        DictionaryRef: ::fidl_next::Encode<___E>,
531    {
532        #[inline]
533        fn encode_option(
534            this: ::core::option::Option<Self>,
535            encoder: &mut ___E,
536            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
537            _: (),
538        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
539            if let Some(inner) = this {
540                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
541                ::fidl_next::WireBox::encode_present(out);
542            } else {
543                ::fidl_next::WireBox::encode_absent(out);
544            }
545
546            Ok(())
547        }
548    }
549
550    impl ::fidl_next::FromWire<crate::wire::DictionaryRef> for DictionaryRef {
551        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DictionaryRef, Self> = unsafe {
552            ::fidl_next::CopyOptimization::enable_if(
553                true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
554                    ::fidl_next::fuchsia::WireEventPair,
555                >>::COPY_OPTIMIZATION
556                    .is_enabled(),
557            )
558        };
559
560        #[inline]
561        fn from_wire(wire: crate::wire::DictionaryRef) -> Self {
562            Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
563        }
564    }
565
566    #[derive(PartialEq, Debug)]
567    #[repr(C)]
568    pub struct Connector {
569        pub token: ::fidl_next::fuchsia::zx::EventPair,
570    }
571
572    impl ::fidl_next::Encodable for Connector {
573        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::Connector> = unsafe {
574            ::fidl_next::CopyOptimization::enable_if(
575            true
576
577                && <
578                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
579                >::COPY_OPTIMIZATION.is_enabled()
580
581        )
582        };
583
584        type Encoded = crate::wire::Connector;
585    }
586
587    unsafe impl<___E> ::fidl_next::Encode<___E> for Connector
588    where
589        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
590        ___E: ::fidl_next::fuchsia::HandleEncoder,
591    {
592        #[inline]
593        fn encode(
594            self,
595            encoder_: &mut ___E,
596            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
597            _: (),
598        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
599            ::fidl_next::munge! {
600                let Self::Encoded {
601                    token,
602
603                } = out_;
604            }
605
606            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
607
608            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
609
610            Ok(())
611        }
612    }
613
614    impl ::fidl_next::EncodableOption for Connector {
615        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Connector>;
616    }
617
618    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Connector
619    where
620        ___E: ::fidl_next::Encoder + ?Sized,
621        Connector: ::fidl_next::Encode<___E>,
622    {
623        #[inline]
624        fn encode_option(
625            this: ::core::option::Option<Self>,
626            encoder: &mut ___E,
627            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
628            _: (),
629        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
630            if let Some(inner) = this {
631                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
632                ::fidl_next::WireBox::encode_present(out);
633            } else {
634                ::fidl_next::WireBox::encode_absent(out);
635            }
636
637            Ok(())
638        }
639    }
640
641    impl ::fidl_next::FromWire<crate::wire::Connector> for Connector {
642        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Connector, Self> = unsafe {
643            ::fidl_next::CopyOptimization::enable_if(
644                true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
645                    ::fidl_next::fuchsia::WireEventPair,
646                >>::COPY_OPTIMIZATION
647                    .is_enabled(),
648            )
649        };
650
651        #[inline]
652        fn from_wire(wire: crate::wire::Connector) -> Self {
653            Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
654        }
655    }
656
657    #[derive(PartialEq, Debug)]
658    #[repr(C)]
659    pub struct DirConnector {
660        pub token: ::fidl_next::fuchsia::zx::EventPair,
661    }
662
663    impl ::fidl_next::Encodable for DirConnector {
664        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirConnector> = unsafe {
665            ::fidl_next::CopyOptimization::enable_if(
666            true
667
668                && <
669                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
670                >::COPY_OPTIMIZATION.is_enabled()
671
672        )
673        };
674
675        type Encoded = crate::wire::DirConnector;
676    }
677
678    unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnector
679    where
680        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
681        ___E: ::fidl_next::fuchsia::HandleEncoder,
682    {
683        #[inline]
684        fn encode(
685            self,
686            encoder_: &mut ___E,
687            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
688            _: (),
689        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
690            ::fidl_next::munge! {
691                let Self::Encoded {
692                    token,
693
694                } = out_;
695            }
696
697            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
698
699            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
700
701            Ok(())
702        }
703    }
704
705    impl ::fidl_next::EncodableOption for DirConnector {
706        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirConnector>;
707    }
708
709    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnector
710    where
711        ___E: ::fidl_next::Encoder + ?Sized,
712        DirConnector: ::fidl_next::Encode<___E>,
713    {
714        #[inline]
715        fn encode_option(
716            this: ::core::option::Option<Self>,
717            encoder: &mut ___E,
718            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
719            _: (),
720        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
721            if let Some(inner) = this {
722                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
723                ::fidl_next::WireBox::encode_present(out);
724            } else {
725                ::fidl_next::WireBox::encode_absent(out);
726            }
727
728            Ok(())
729        }
730    }
731
732    impl ::fidl_next::FromWire<crate::wire::DirConnector> for DirConnector {
733        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirConnector, Self> = unsafe {
734            ::fidl_next::CopyOptimization::enable_if(
735                true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
736                    ::fidl_next::fuchsia::WireEventPair,
737                >>::COPY_OPTIMIZATION
738                    .is_enabled(),
739            )
740        };
741
742        #[inline]
743        fn from_wire(wire: crate::wire::DirConnector) -> Self {
744            Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
745        }
746    }
747
748    #[derive(PartialEq, Debug)]
749    #[repr(C)]
750    pub struct DirEntry {
751        pub token: ::fidl_next::fuchsia::zx::EventPair,
752    }
753
754    impl ::fidl_next::Encodable for DirEntry {
755        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::DirEntry> = unsafe {
756            ::fidl_next::CopyOptimization::enable_if(
757            true
758
759                && <
760                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
761                >::COPY_OPTIMIZATION.is_enabled()
762
763        )
764        };
765
766        type Encoded = crate::wire::DirEntry;
767    }
768
769    unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntry
770    where
771        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
772        ___E: ::fidl_next::fuchsia::HandleEncoder,
773    {
774        #[inline]
775        fn encode(
776            self,
777            encoder_: &mut ___E,
778            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
779            _: (),
780        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
781            ::fidl_next::munge! {
782                let Self::Encoded {
783                    token,
784
785                } = out_;
786            }
787
788            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
789
790            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
791
792            Ok(())
793        }
794    }
795
796    impl ::fidl_next::EncodableOption for DirEntry {
797        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirEntry>;
798    }
799
800    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntry
801    where
802        ___E: ::fidl_next::Encoder + ?Sized,
803        DirEntry: ::fidl_next::Encode<___E>,
804    {
805        #[inline]
806        fn encode_option(
807            this: ::core::option::Option<Self>,
808            encoder: &mut ___E,
809            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
810            _: (),
811        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
812            if let Some(inner) = this {
813                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
814                ::fidl_next::WireBox::encode_present(out);
815            } else {
816                ::fidl_next::WireBox::encode_absent(out);
817            }
818
819            Ok(())
820        }
821    }
822
823    impl ::fidl_next::FromWire<crate::wire::DirEntry> for DirEntry {
824        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::DirEntry, Self> = unsafe {
825            ::fidl_next::CopyOptimization::enable_if(
826                true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
827                    ::fidl_next::fuchsia::WireEventPair,
828                >>::COPY_OPTIMIZATION
829                    .is_enabled(),
830            )
831        };
832
833        #[inline]
834        fn from_wire(wire: crate::wire::DirEntry) -> Self {
835            Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
836        }
837    }
838
839    #[derive(PartialEq, Debug)]
840    pub enum Capability {
841        Unit(crate::natural::Unit),
842
843        Handle(::fidl_next::fuchsia::zx::Handle),
844
845        Data(crate::natural::Data),
846
847        Dictionary(crate::natural::DictionaryRef),
848
849        Connector(crate::natural::Connector),
850
851        DirConnector(crate::natural::DirConnector),
852
853        Directory(
854            ::fidl_next::ClientEnd<
855                ::fidl_next_fuchsia_io::Directory,
856                ::fidl_next::fuchsia::zx::Channel,
857            >,
858        ),
859
860        DirEntry(crate::natural::DirEntry),
861
862        ConnectorRouter(
863            ::fidl_next::ClientEnd<crate::ConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
864        ),
865
866        DictionaryRouter(
867            ::fidl_next::ClientEnd<crate::DictionaryRouter, ::fidl_next::fuchsia::zx::Channel>,
868        ),
869
870        DirEntryRouter(
871            ::fidl_next::ClientEnd<crate::DirEntryRouter, ::fidl_next::fuchsia::zx::Channel>,
872        ),
873
874        DataRouter(::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>),
875
876        DirConnectorRouter(
877            ::fidl_next::ClientEnd<crate::DirConnectorRouter, ::fidl_next::fuchsia::zx::Channel>,
878        ),
879
880        UnknownOrdinal_(u64),
881    }
882
883    impl Capability {
884        pub fn is_unknown(&self) -> bool {
885            #[allow(unreachable_patterns)]
886            match self {
887                Self::UnknownOrdinal_(_) => true,
888                _ => false,
889            }
890        }
891    }
892
893    impl ::fidl_next::Encodable for Capability {
894        type Encoded = crate::wire::Capability<'static>;
895    }
896
897    unsafe impl<___E> ::fidl_next::Encode<___E> for Capability
898    where
899        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
900        ___E: ::fidl_next::Encoder,
901        ___E: ::fidl_next::fuchsia::HandleEncoder,
902    {
903        #[inline]
904        fn encode(
905            self,
906            encoder: &mut ___E,
907            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
908            _: (),
909        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
910            ::fidl_next::munge!(let crate::wire::Capability { raw, _phantom: _ } = out);
911
912            match self {
913                Self::Unit(value) => ::fidl_next::RawWireUnion::encode_as::<
914                    ___E,
915                    crate::natural::Unit,
916                >(value, 1, encoder, raw, ())?,
917
918                Self::Handle(value) => ::fidl_next::RawWireUnion::encode_as::<
919                    ___E,
920                    ::fidl_next::fuchsia::zx::Handle,
921                >(value, 2, encoder, raw, ())?,
922
923                Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
924                    ___E,
925                    crate::natural::Data,
926                >(value, 3, encoder, raw, ())?,
927
928                Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as::<
929                    ___E,
930                    crate::natural::DictionaryRef,
931                >(value, 4, encoder, raw, ())?,
932
933                Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as::<
934                    ___E,
935                    crate::natural::Connector,
936                >(value, 5, encoder, raw, ())?,
937
938                Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as::<
939                    ___E,
940                    crate::natural::DirConnector,
941                >(value, 6, encoder, raw, ())?,
942
943                Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as::<
944                    ___E,
945                    ::fidl_next::ClientEnd<
946                        ::fidl_next_fuchsia_io::Directory,
947                        ::fidl_next::fuchsia::zx::Channel,
948                    >,
949                >(value, 7, encoder, raw, ())?,
950
951                Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as::<
952                    ___E,
953                    crate::natural::DirEntry,
954                >(value, 8, encoder, raw, ())?,
955
956                Self::ConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
957                    ___E,
958                    ::fidl_next::ClientEnd<
959                        crate::ConnectorRouter,
960                        ::fidl_next::fuchsia::zx::Channel,
961                    >,
962                >(value, 9, encoder, raw, ())?,
963
964                Self::DictionaryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
965                    ___E,
966                    ::fidl_next::ClientEnd<
967                        crate::DictionaryRouter,
968                        ::fidl_next::fuchsia::zx::Channel,
969                    >,
970                >(value, 10, encoder, raw, ())?,
971
972                Self::DirEntryRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
973                    ___E,
974                    ::fidl_next::ClientEnd<
975                        crate::DirEntryRouter,
976                        ::fidl_next::fuchsia::zx::Channel,
977                    >,
978                >(value, 11, encoder, raw, ())?,
979
980                Self::DataRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
981                    ___E,
982                    ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::zx::Channel>,
983                >(value, 12, encoder, raw, ())?,
984
985                Self::DirConnectorRouter(value) => ::fidl_next::RawWireUnion::encode_as::<
986                    ___E,
987                    ::fidl_next::ClientEnd<
988                        crate::DirConnectorRouter,
989                        ::fidl_next::fuchsia::zx::Channel,
990                    >,
991                >(value, 13, encoder, raw, ())?,
992
993                Self::UnknownOrdinal_(ordinal) => {
994                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
995                }
996            }
997
998            Ok(())
999        }
1000    }
1001
1002    impl ::fidl_next::EncodableOption for Capability {
1003        type EncodedOption = crate::wire_optional::Capability<'static>;
1004    }
1005
1006    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Capability
1007    where
1008        ___E: ?Sized,
1009        Capability: ::fidl_next::Encode<___E>,
1010    {
1011        #[inline]
1012        fn encode_option(
1013            this: ::core::option::Option<Self>,
1014            encoder: &mut ___E,
1015            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1016            _: (),
1017        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1018            ::fidl_next::munge!(let crate::wire_optional::Capability { raw, _phantom: _ } = &mut *out);
1019
1020            if let Some(inner) = this {
1021                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1022                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1023            } else {
1024                ::fidl_next::RawWireUnion::encode_absent(raw);
1025            }
1026
1027            Ok(())
1028        }
1029    }
1030
1031    impl<'de> ::fidl_next::FromWire<crate::wire::Capability<'de>> for Capability {
1032        #[inline]
1033        fn from_wire(wire: crate::wire::Capability<'de>) -> Self {
1034            let wire = ::core::mem::ManuallyDrop::new(wire);
1035            match wire.raw.ordinal() {
1036                1 => Self::Unit(::fidl_next::FromWire::from_wire(unsafe {
1037                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
1038                })),
1039
1040                2 => Self::Handle(::fidl_next::FromWire::from_wire(unsafe {
1041                    wire.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
1042                })),
1043
1044                3 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
1045                    wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
1046                })),
1047
1048                4 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
1049                    wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
1050                })),
1051
1052                5 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
1053                    wire.raw.get().read_unchecked::<crate::wire::Connector>()
1054                })),
1055
1056                6 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
1057                    wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
1058                })),
1059
1060                7 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1061                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1062                        ::fidl_next_fuchsia_io::Directory,
1063                        ::fidl_next::fuchsia::WireChannel,
1064                    >>()
1065                })),
1066
1067                8 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
1068                    wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
1069                })),
1070
1071                9 => Self::ConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1072                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1073                        crate::ConnectorRouter,
1074                        ::fidl_next::fuchsia::WireChannel,
1075                    >>()
1076                })),
1077
1078                10 => Self::DictionaryRouter(::fidl_next::FromWire::from_wire(unsafe {
1079                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1080                        crate::DictionaryRouter,
1081                        ::fidl_next::fuchsia::WireChannel,
1082                    >>()
1083                })),
1084
1085                11 => Self::DirEntryRouter(::fidl_next::FromWire::from_wire(unsafe {
1086                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1087                        crate::DirEntryRouter,
1088                        ::fidl_next::fuchsia::WireChannel,
1089                    >>()
1090                })),
1091
1092                12 => Self::DataRouter(::fidl_next::FromWire::from_wire(unsafe {
1093                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
1094                })),
1095
1096                13 => Self::DirConnectorRouter(::fidl_next::FromWire::from_wire(unsafe {
1097                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
1098                        crate::DirConnectorRouter,
1099                        ::fidl_next::fuchsia::WireChannel,
1100                    >>()
1101                })),
1102
1103                ord => return Self::UnknownOrdinal_(ord as u64),
1104            }
1105        }
1106    }
1107
1108    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Capability {
1109        #[inline]
1110        fn from_wire_option(
1111            wire: crate::wire_optional::Capability<'de>,
1112        ) -> ::core::option::Option<Self> {
1113            if let Some(inner) = wire.into_option() {
1114                Some(::fidl_next::FromWire::from_wire(inner))
1115            } else {
1116                None
1117            }
1118        }
1119    }
1120
1121    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>> for Box<Capability> {
1122        #[inline]
1123        fn from_wire_option(
1124            wire: crate::wire_optional::Capability<'de>,
1125        ) -> ::core::option::Option<Self> {
1126            <
1127            Capability as ::fidl_next::FromWireOption<crate::wire_optional::Capability<'de>>
1128        >::from_wire_option(wire).map(Box::new)
1129        }
1130    }
1131
1132    #[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"]
1133    pub type CapabilityId = u64;
1134
1135    #[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"]
1136    pub type NewCapabilityId = u64;
1137
1138    #[derive(PartialEq, Clone, Debug)]
1139    #[repr(C)]
1140    pub struct CapabilityStoreDuplicateRequest {
1141        pub id: u64,
1142
1143        pub dest_id: u64,
1144    }
1145
1146    impl ::fidl_next::Encodable for CapabilityStoreDuplicateRequest {
1147        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1148            Self,
1149            crate::wire::CapabilityStoreDuplicateRequest,
1150        > = unsafe {
1151            ::fidl_next::CopyOptimization::enable_if(
1152                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
1153                    && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1154            )
1155        };
1156
1157        type Encoded = crate::wire::CapabilityStoreDuplicateRequest;
1158    }
1159
1160    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest
1161    where
1162        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1163    {
1164        #[inline]
1165        fn encode(
1166            self,
1167            encoder_: &mut ___E,
1168            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1169            _: (),
1170        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1171            ::fidl_next::munge! {
1172                let Self::Encoded {
1173                    id,
1174                    dest_id,
1175
1176                } = out_;
1177            }
1178
1179            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1180
1181            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1182
1183            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
1184
1185            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1186
1187            Ok(())
1188        }
1189    }
1190
1191    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateRequest
1192    where
1193        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1194    {
1195        #[inline]
1196        fn encode_ref(
1197            &self,
1198            encoder_: &mut ___E,
1199            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1200            _: (),
1201        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1202            ::fidl_next::munge! {
1203                let Self::Encoded {
1204
1205                    id,
1206                    dest_id,
1207
1208                } = out_;
1209            }
1210
1211            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1212
1213            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1214
1215            ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
1216
1217            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
1218
1219            Ok(())
1220        }
1221    }
1222
1223    impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateRequest {
1224        type EncodedOption =
1225            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDuplicateRequest>;
1226    }
1227
1228    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateRequest
1229    where
1230        ___E: ::fidl_next::Encoder + ?Sized,
1231        CapabilityStoreDuplicateRequest: ::fidl_next::Encode<___E>,
1232    {
1233        #[inline]
1234        fn encode_option(
1235            this: ::core::option::Option<Self>,
1236            encoder: &mut ___E,
1237            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1238            _: (),
1239        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1240            if let Some(inner) = this {
1241                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1242                ::fidl_next::WireBox::encode_present(out);
1243            } else {
1244                ::fidl_next::WireBox::encode_absent(out);
1245            }
1246
1247            Ok(())
1248        }
1249    }
1250
1251    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateRequest
1252    where
1253        ___E: ::fidl_next::Encoder + ?Sized,
1254        CapabilityStoreDuplicateRequest: ::fidl_next::EncodeRef<___E>,
1255    {
1256        #[inline]
1257        fn encode_option_ref(
1258            this: ::core::option::Option<&Self>,
1259            encoder: &mut ___E,
1260            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1261            _: (),
1262        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1263            if let Some(inner) = this {
1264                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1265                ::fidl_next::WireBox::encode_present(out);
1266            } else {
1267                ::fidl_next::WireBox::encode_absent(out);
1268            }
1269
1270            Ok(())
1271        }
1272    }
1273
1274    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateRequest>
1275        for CapabilityStoreDuplicateRequest
1276    {
1277        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1278            crate::wire::CapabilityStoreDuplicateRequest,
1279            Self,
1280        > = unsafe {
1281            ::fidl_next::CopyOptimization::enable_if(
1282                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1283                    .is_enabled()
1284                    && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1285                        .is_enabled(),
1286            )
1287        };
1288
1289        #[inline]
1290        fn from_wire(wire: crate::wire::CapabilityStoreDuplicateRequest) -> Self {
1291            Self {
1292                id: ::fidl_next::FromWire::from_wire(wire.id),
1293
1294                dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
1295            }
1296        }
1297    }
1298
1299    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateRequest>
1300        for CapabilityStoreDuplicateRequest
1301    {
1302        #[inline]
1303        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateRequest) -> Self {
1304            Self {
1305                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1306
1307                dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
1308            }
1309        }
1310    }
1311
1312    #[derive(PartialEq, Clone, Debug)]
1313    #[repr(C)]
1314    pub struct CapabilityStoreDuplicateResponse {}
1315
1316    impl ::fidl_next::Encodable for CapabilityStoreDuplicateResponse {
1317        type Encoded = crate::wire::CapabilityStoreDuplicateResponse;
1318    }
1319
1320    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateResponse
1321    where
1322        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1323    {
1324        #[inline]
1325        fn encode(
1326            self,
1327            encoder_: &mut ___E,
1328            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1329            _: (),
1330        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1331            *out_ = ::core::mem::MaybeUninit::zeroed();
1332
1333            Ok(())
1334        }
1335    }
1336
1337    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDuplicateResponse
1338    where
1339        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1340    {
1341        #[inline]
1342        fn encode_ref(
1343            &self,
1344            encoder_: &mut ___E,
1345            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1346            _: (),
1347        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1348            ::fidl_next::munge! {
1349                let Self::Encoded {
1350
1351                        _empty,
1352
1353
1354                } = out_;
1355            }
1356
1357            Ok(())
1358        }
1359    }
1360
1361    impl ::fidl_next::EncodableOption for CapabilityStoreDuplicateResponse {
1362        type EncodedOption =
1363            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDuplicateResponse>;
1364    }
1365
1366    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDuplicateResponse
1367    where
1368        ___E: ::fidl_next::Encoder + ?Sized,
1369        CapabilityStoreDuplicateResponse: ::fidl_next::Encode<___E>,
1370    {
1371        #[inline]
1372        fn encode_option(
1373            this: ::core::option::Option<Self>,
1374            encoder: &mut ___E,
1375            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1376            _: (),
1377        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1378            if let Some(inner) = this {
1379                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1380                ::fidl_next::WireBox::encode_present(out);
1381            } else {
1382                ::fidl_next::WireBox::encode_absent(out);
1383            }
1384
1385            Ok(())
1386        }
1387    }
1388
1389    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDuplicateResponse
1390    where
1391        ___E: ::fidl_next::Encoder + ?Sized,
1392        CapabilityStoreDuplicateResponse: ::fidl_next::EncodeRef<___E>,
1393    {
1394        #[inline]
1395        fn encode_option_ref(
1396            this: ::core::option::Option<&Self>,
1397            encoder: &mut ___E,
1398            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1399            _: (),
1400        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1401            if let Some(inner) = this {
1402                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1403                ::fidl_next::WireBox::encode_present(out);
1404            } else {
1405                ::fidl_next::WireBox::encode_absent(out);
1406            }
1407
1408            Ok(())
1409        }
1410    }
1411
1412    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDuplicateResponse>
1413        for CapabilityStoreDuplicateResponse
1414    {
1415        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1416            crate::wire::CapabilityStoreDuplicateResponse,
1417            Self,
1418        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1419
1420        #[inline]
1421        fn from_wire(wire: crate::wire::CapabilityStoreDuplicateResponse) -> Self {
1422            Self {}
1423        }
1424    }
1425
1426    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDuplicateResponse>
1427        for CapabilityStoreDuplicateResponse
1428    {
1429        #[inline]
1430        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDuplicateResponse) -> Self {
1431            Self {}
1432        }
1433    }
1434
1435    #[doc = " Error returned from methods in [CapabilityStore].\n"]
1436    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
1437    #[repr(u32)]
1438    pub enum CapabilityStoreError {
1439        IdNotFound = 1,
1440        IdAlreadyExists = 2,
1441        BadCapability = 3,
1442        WrongType = 4,
1443        NotDuplicatable = 5,
1444        ItemNotFound = 6,
1445        ItemAlreadyExists = 7,
1446        InvalidKey = 8,
1447        InvalidArgs = 9,
1448        UnknownOrdinal_(u32) = 10,
1449    }
1450
1451    impl ::fidl_next::Encodable for CapabilityStoreError {
1452        type Encoded = crate::wire::CapabilityStoreError;
1453    }
1454    impl ::std::convert::From<u32> for CapabilityStoreError {
1455        fn from(value: u32) -> Self {
1456            match value {
1457                1 => Self::IdNotFound,
1458                2 => Self::IdAlreadyExists,
1459                3 => Self::BadCapability,
1460                4 => Self::WrongType,
1461                5 => Self::NotDuplicatable,
1462                6 => Self::ItemNotFound,
1463                7 => Self::ItemAlreadyExists,
1464                8 => Self::InvalidKey,
1465                9 => Self::InvalidArgs,
1466
1467                _ => Self::UnknownOrdinal_(value),
1468            }
1469        }
1470    }
1471
1472    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreError
1473    where
1474        ___E: ?Sized,
1475    {
1476        #[inline]
1477        fn encode(
1478            self,
1479            encoder: &mut ___E,
1480            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1481            _: (),
1482        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1483            ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
1484        }
1485    }
1486
1487    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreError
1488    where
1489        ___E: ?Sized,
1490    {
1491        #[inline]
1492        fn encode_ref(
1493            &self,
1494            encoder: &mut ___E,
1495            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1496            _: (),
1497        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1498            ::fidl_next::munge!(let crate::wire::CapabilityStoreError { value } = out);
1499            let _ = value.write(::fidl_next::WireU32::from(match *self {
1500                Self::IdNotFound => 1,
1501
1502                Self::IdAlreadyExists => 2,
1503
1504                Self::BadCapability => 3,
1505
1506                Self::WrongType => 4,
1507
1508                Self::NotDuplicatable => 5,
1509
1510                Self::ItemNotFound => 6,
1511
1512                Self::ItemAlreadyExists => 7,
1513
1514                Self::InvalidKey => 8,
1515
1516                Self::InvalidArgs => 9,
1517
1518                Self::UnknownOrdinal_(value) => value,
1519            }));
1520
1521            Ok(())
1522        }
1523    }
1524
1525    impl ::core::convert::From<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1526        fn from(wire: crate::wire::CapabilityStoreError) -> Self {
1527            match u32::from(wire.value) {
1528                1 => Self::IdNotFound,
1529
1530                2 => Self::IdAlreadyExists,
1531
1532                3 => Self::BadCapability,
1533
1534                4 => Self::WrongType,
1535
1536                5 => Self::NotDuplicatable,
1537
1538                6 => Self::ItemNotFound,
1539
1540                7 => Self::ItemAlreadyExists,
1541
1542                8 => Self::InvalidKey,
1543
1544                9 => Self::InvalidArgs,
1545
1546                value => Self::UnknownOrdinal_(value),
1547            }
1548        }
1549    }
1550
1551    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1552        #[inline]
1553        fn from_wire(wire: crate::wire::CapabilityStoreError) -> Self {
1554            Self::from(wire)
1555        }
1556    }
1557
1558    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreError> for CapabilityStoreError {
1559        #[inline]
1560        fn from_wire_ref(wire: &crate::wire::CapabilityStoreError) -> Self {
1561            Self::from(*wire)
1562        }
1563    }
1564
1565    #[derive(PartialEq, Clone, Debug)]
1566    #[repr(C)]
1567    pub struct CapabilityStoreDropRequest {
1568        pub id: u64,
1569    }
1570
1571    impl ::fidl_next::Encodable for CapabilityStoreDropRequest {
1572        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1573            Self,
1574            crate::wire::CapabilityStoreDropRequest,
1575        > = unsafe {
1576            ::fidl_next::CopyOptimization::enable_if(
1577                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1578            )
1579        };
1580
1581        type Encoded = crate::wire::CapabilityStoreDropRequest;
1582    }
1583
1584    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest
1585    where
1586        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1587    {
1588        #[inline]
1589        fn encode(
1590            self,
1591            encoder_: &mut ___E,
1592            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1593            _: (),
1594        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1595            ::fidl_next::munge! {
1596                let Self::Encoded {
1597                    id,
1598
1599                } = out_;
1600            }
1601
1602            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1603
1604            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1605
1606            Ok(())
1607        }
1608    }
1609
1610    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropRequest
1611    where
1612        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1613    {
1614        #[inline]
1615        fn encode_ref(
1616            &self,
1617            encoder_: &mut ___E,
1618            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1619            _: (),
1620        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1621            ::fidl_next::munge! {
1622                let Self::Encoded {
1623
1624                    id,
1625
1626                } = out_;
1627            }
1628
1629            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1630
1631            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1632
1633            Ok(())
1634        }
1635    }
1636
1637    impl ::fidl_next::EncodableOption for CapabilityStoreDropRequest {
1638        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDropRequest>;
1639    }
1640
1641    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropRequest
1642    where
1643        ___E: ::fidl_next::Encoder + ?Sized,
1644        CapabilityStoreDropRequest: ::fidl_next::Encode<___E>,
1645    {
1646        #[inline]
1647        fn encode_option(
1648            this: ::core::option::Option<Self>,
1649            encoder: &mut ___E,
1650            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1651            _: (),
1652        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1653            if let Some(inner) = this {
1654                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1655                ::fidl_next::WireBox::encode_present(out);
1656            } else {
1657                ::fidl_next::WireBox::encode_absent(out);
1658            }
1659
1660            Ok(())
1661        }
1662    }
1663
1664    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropRequest
1665    where
1666        ___E: ::fidl_next::Encoder + ?Sized,
1667        CapabilityStoreDropRequest: ::fidl_next::EncodeRef<___E>,
1668    {
1669        #[inline]
1670        fn encode_option_ref(
1671            this: ::core::option::Option<&Self>,
1672            encoder: &mut ___E,
1673            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1674            _: (),
1675        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1676            if let Some(inner) = this {
1677                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1678                ::fidl_next::WireBox::encode_present(out);
1679            } else {
1680                ::fidl_next::WireBox::encode_absent(out);
1681            }
1682
1683            Ok(())
1684        }
1685    }
1686
1687    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropRequest> for CapabilityStoreDropRequest {
1688        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1689            crate::wire::CapabilityStoreDropRequest,
1690            Self,
1691        > = unsafe {
1692            ::fidl_next::CopyOptimization::enable_if(
1693                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1694                    .is_enabled(),
1695            )
1696        };
1697
1698        #[inline]
1699        fn from_wire(wire: crate::wire::CapabilityStoreDropRequest) -> Self {
1700            Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1701        }
1702    }
1703
1704    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropRequest>
1705        for CapabilityStoreDropRequest
1706    {
1707        #[inline]
1708        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropRequest) -> Self {
1709            Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1710        }
1711    }
1712
1713    #[derive(PartialEq, Clone, Debug)]
1714    #[repr(C)]
1715    pub struct CapabilityStoreDropResponse {}
1716
1717    impl ::fidl_next::Encodable for CapabilityStoreDropResponse {
1718        type Encoded = crate::wire::CapabilityStoreDropResponse;
1719    }
1720
1721    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDropResponse
1722    where
1723        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1724    {
1725        #[inline]
1726        fn encode(
1727            self,
1728            encoder_: &mut ___E,
1729            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1730            _: (),
1731        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1732            *out_ = ::core::mem::MaybeUninit::zeroed();
1733
1734            Ok(())
1735        }
1736    }
1737
1738    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDropResponse
1739    where
1740        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1741    {
1742        #[inline]
1743        fn encode_ref(
1744            &self,
1745            encoder_: &mut ___E,
1746            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1747            _: (),
1748        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1749            ::fidl_next::munge! {
1750                let Self::Encoded {
1751
1752                        _empty,
1753
1754
1755                } = out_;
1756            }
1757
1758            Ok(())
1759        }
1760    }
1761
1762    impl ::fidl_next::EncodableOption for CapabilityStoreDropResponse {
1763        type EncodedOption =
1764            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDropResponse>;
1765    }
1766
1767    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDropResponse
1768    where
1769        ___E: ::fidl_next::Encoder + ?Sized,
1770        CapabilityStoreDropResponse: ::fidl_next::Encode<___E>,
1771    {
1772        #[inline]
1773        fn encode_option(
1774            this: ::core::option::Option<Self>,
1775            encoder: &mut ___E,
1776            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1777            _: (),
1778        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1779            if let Some(inner) = this {
1780                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1781                ::fidl_next::WireBox::encode_present(out);
1782            } else {
1783                ::fidl_next::WireBox::encode_absent(out);
1784            }
1785
1786            Ok(())
1787        }
1788    }
1789
1790    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDropResponse
1791    where
1792        ___E: ::fidl_next::Encoder + ?Sized,
1793        CapabilityStoreDropResponse: ::fidl_next::EncodeRef<___E>,
1794    {
1795        #[inline]
1796        fn encode_option_ref(
1797            this: ::core::option::Option<&Self>,
1798            encoder: &mut ___E,
1799            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1800            _: (),
1801        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1802            if let Some(inner) = this {
1803                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1804                ::fidl_next::WireBox::encode_present(out);
1805            } else {
1806                ::fidl_next::WireBox::encode_absent(out);
1807            }
1808
1809            Ok(())
1810        }
1811    }
1812
1813    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDropResponse>
1814        for CapabilityStoreDropResponse
1815    {
1816        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1817            crate::wire::CapabilityStoreDropResponse,
1818            Self,
1819        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
1820
1821        #[inline]
1822        fn from_wire(wire: crate::wire::CapabilityStoreDropResponse) -> Self {
1823            Self {}
1824        }
1825    }
1826
1827    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDropResponse>
1828        for CapabilityStoreDropResponse
1829    {
1830        #[inline]
1831        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDropResponse) -> Self {
1832            Self {}
1833        }
1834    }
1835
1836    #[derive(PartialEq, Clone, Debug)]
1837    #[repr(C)]
1838    pub struct CapabilityStoreExportRequest {
1839        pub id: u64,
1840    }
1841
1842    impl ::fidl_next::Encodable for CapabilityStoreExportRequest {
1843        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1844            Self,
1845            crate::wire::CapabilityStoreExportRequest,
1846        > = unsafe {
1847            ::fidl_next::CopyOptimization::enable_if(
1848                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
1849            )
1850        };
1851
1852        type Encoded = crate::wire::CapabilityStoreExportRequest;
1853    }
1854
1855    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest
1856    where
1857        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1858    {
1859        #[inline]
1860        fn encode(
1861            self,
1862            encoder_: &mut ___E,
1863            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1864            _: (),
1865        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1866            ::fidl_next::munge! {
1867                let Self::Encoded {
1868                    id,
1869
1870                } = out_;
1871            }
1872
1873            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1874
1875            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1876
1877            Ok(())
1878        }
1879    }
1880
1881    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreExportRequest
1882    where
1883        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1884    {
1885        #[inline]
1886        fn encode_ref(
1887            &self,
1888            encoder_: &mut ___E,
1889            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
1890            _: (),
1891        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1892            ::fidl_next::munge! {
1893                let Self::Encoded {
1894
1895                    id,
1896
1897                } = out_;
1898            }
1899
1900            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
1901
1902            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1903
1904            Ok(())
1905        }
1906    }
1907
1908    impl ::fidl_next::EncodableOption for CapabilityStoreExportRequest {
1909        type EncodedOption =
1910            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportRequest>;
1911    }
1912
1913    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportRequest
1914    where
1915        ___E: ::fidl_next::Encoder + ?Sized,
1916        CapabilityStoreExportRequest: ::fidl_next::Encode<___E>,
1917    {
1918        #[inline]
1919        fn encode_option(
1920            this: ::core::option::Option<Self>,
1921            encoder: &mut ___E,
1922            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1923            _: (),
1924        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1925            if let Some(inner) = this {
1926                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1927                ::fidl_next::WireBox::encode_present(out);
1928            } else {
1929                ::fidl_next::WireBox::encode_absent(out);
1930            }
1931
1932            Ok(())
1933        }
1934    }
1935
1936    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreExportRequest
1937    where
1938        ___E: ::fidl_next::Encoder + ?Sized,
1939        CapabilityStoreExportRequest: ::fidl_next::EncodeRef<___E>,
1940    {
1941        #[inline]
1942        fn encode_option_ref(
1943            this: ::core::option::Option<&Self>,
1944            encoder: &mut ___E,
1945            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
1946            _: (),
1947        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1948            if let Some(inner) = this {
1949                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
1950                ::fidl_next::WireBox::encode_present(out);
1951            } else {
1952                ::fidl_next::WireBox::encode_absent(out);
1953            }
1954
1955            Ok(())
1956        }
1957    }
1958
1959    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreExportRequest>
1960        for CapabilityStoreExportRequest
1961    {
1962        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1963            crate::wire::CapabilityStoreExportRequest,
1964            Self,
1965        > = unsafe {
1966            ::fidl_next::CopyOptimization::enable_if(
1967                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
1968                    .is_enabled(),
1969            )
1970        };
1971
1972        #[inline]
1973        fn from_wire(wire: crate::wire::CapabilityStoreExportRequest) -> Self {
1974            Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
1975        }
1976    }
1977
1978    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreExportRequest>
1979        for CapabilityStoreExportRequest
1980    {
1981        #[inline]
1982        fn from_wire_ref(wire: &crate::wire::CapabilityStoreExportRequest) -> Self {
1983            Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
1984        }
1985    }
1986
1987    #[derive(PartialEq, Clone, Debug)]
1988    #[repr(C)]
1989    pub struct CapabilityStoreImportResponse {}
1990
1991    impl ::fidl_next::Encodable for CapabilityStoreImportResponse {
1992        type Encoded = crate::wire::CapabilityStoreImportResponse;
1993    }
1994
1995    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportResponse
1996    where
1997        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1998    {
1999        #[inline]
2000        fn encode(
2001            self,
2002            encoder_: &mut ___E,
2003            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2004            _: (),
2005        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2006            *out_ = ::core::mem::MaybeUninit::zeroed();
2007
2008            Ok(())
2009        }
2010    }
2011
2012    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreImportResponse
2013    where
2014        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2015    {
2016        #[inline]
2017        fn encode_ref(
2018            &self,
2019            encoder_: &mut ___E,
2020            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2021            _: (),
2022        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2023            ::fidl_next::munge! {
2024                let Self::Encoded {
2025
2026                        _empty,
2027
2028
2029                } = out_;
2030            }
2031
2032            Ok(())
2033        }
2034    }
2035
2036    impl ::fidl_next::EncodableOption for CapabilityStoreImportResponse {
2037        type EncodedOption =
2038            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportResponse>;
2039    }
2040
2041    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportResponse
2042    where
2043        ___E: ::fidl_next::Encoder + ?Sized,
2044        CapabilityStoreImportResponse: ::fidl_next::Encode<___E>,
2045    {
2046        #[inline]
2047        fn encode_option(
2048            this: ::core::option::Option<Self>,
2049            encoder: &mut ___E,
2050            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2051            _: (),
2052        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2053            if let Some(inner) = this {
2054                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2055                ::fidl_next::WireBox::encode_present(out);
2056            } else {
2057                ::fidl_next::WireBox::encode_absent(out);
2058            }
2059
2060            Ok(())
2061        }
2062    }
2063
2064    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreImportResponse
2065    where
2066        ___E: ::fidl_next::Encoder + ?Sized,
2067        CapabilityStoreImportResponse: ::fidl_next::EncodeRef<___E>,
2068    {
2069        #[inline]
2070        fn encode_option_ref(
2071            this: ::core::option::Option<&Self>,
2072            encoder: &mut ___E,
2073            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2074            _: (),
2075        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2076            if let Some(inner) = this {
2077                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2078                ::fidl_next::WireBox::encode_present(out);
2079            } else {
2080                ::fidl_next::WireBox::encode_absent(out);
2081            }
2082
2083            Ok(())
2084        }
2085    }
2086
2087    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreImportResponse>
2088        for CapabilityStoreImportResponse
2089    {
2090        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2091            crate::wire::CapabilityStoreImportResponse,
2092            Self,
2093        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2094
2095        #[inline]
2096        fn from_wire(wire: crate::wire::CapabilityStoreImportResponse) -> Self {
2097            Self {}
2098        }
2099    }
2100
2101    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreImportResponse>
2102        for CapabilityStoreImportResponse
2103    {
2104        #[inline]
2105        fn from_wire_ref(wire: &crate::wire::CapabilityStoreImportResponse) -> Self {
2106            Self {}
2107        }
2108    }
2109
2110    #[derive(PartialEq, Debug)]
2111    pub struct CapabilityStoreConnectorCreateRequest {
2112        pub id: u64,
2113
2114        pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::zx::Channel>,
2115    }
2116
2117    impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest {
2118        type Encoded = crate::wire::CapabilityStoreConnectorCreateRequest;
2119    }
2120
2121    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateRequest
2122    where
2123        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2124        ___E: ::fidl_next::fuchsia::HandleEncoder,
2125    {
2126        #[inline]
2127        fn encode(
2128            self,
2129            encoder_: &mut ___E,
2130            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2131            _: (),
2132        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2133            ::fidl_next::munge! {
2134                let Self::Encoded {
2135                    id,
2136                    receiver,
2137
2138                } = out_;
2139            }
2140
2141            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2142
2143            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2144
2145            ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
2146
2147            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
2148
2149            Ok(())
2150        }
2151    }
2152
2153    impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateRequest {
2154        type EncodedOption =
2155            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateRequest>;
2156    }
2157
2158    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateRequest
2159    where
2160        ___E: ::fidl_next::Encoder + ?Sized,
2161        CapabilityStoreConnectorCreateRequest: ::fidl_next::Encode<___E>,
2162    {
2163        #[inline]
2164        fn encode_option(
2165            this: ::core::option::Option<Self>,
2166            encoder: &mut ___E,
2167            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2168            _: (),
2169        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2170            if let Some(inner) = this {
2171                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2172                ::fidl_next::WireBox::encode_present(out);
2173            } else {
2174                ::fidl_next::WireBox::encode_absent(out);
2175            }
2176
2177            Ok(())
2178        }
2179    }
2180
2181    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateRequest>
2182        for CapabilityStoreConnectorCreateRequest
2183    {
2184        #[inline]
2185        fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateRequest) -> Self {
2186            Self {
2187                id: ::fidl_next::FromWire::from_wire(wire.id),
2188
2189                receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
2190            }
2191        }
2192    }
2193
2194    #[derive(PartialEq, Clone, Debug)]
2195    #[repr(C)]
2196    pub struct CapabilityStoreConnectorCreateResponse {}
2197
2198    impl ::fidl_next::Encodable for CapabilityStoreConnectorCreateResponse {
2199        type Encoded = crate::wire::CapabilityStoreConnectorCreateResponse;
2200    }
2201
2202    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorCreateResponse
2203    where
2204        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2205    {
2206        #[inline]
2207        fn encode(
2208            self,
2209            encoder_: &mut ___E,
2210            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2211            _: (),
2212        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2213            *out_ = ::core::mem::MaybeUninit::zeroed();
2214
2215            Ok(())
2216        }
2217    }
2218
2219    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreConnectorCreateResponse
2220    where
2221        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2222    {
2223        #[inline]
2224        fn encode_ref(
2225            &self,
2226            encoder_: &mut ___E,
2227            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2228            _: (),
2229        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2230            ::fidl_next::munge! {
2231                let Self::Encoded {
2232
2233                        _empty,
2234
2235
2236                } = out_;
2237            }
2238
2239            Ok(())
2240        }
2241    }
2242
2243    impl ::fidl_next::EncodableOption for CapabilityStoreConnectorCreateResponse {
2244        type EncodedOption =
2245            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorCreateResponse>;
2246    }
2247
2248    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorCreateResponse
2249    where
2250        ___E: ::fidl_next::Encoder + ?Sized,
2251        CapabilityStoreConnectorCreateResponse: ::fidl_next::Encode<___E>,
2252    {
2253        #[inline]
2254        fn encode_option(
2255            this: ::core::option::Option<Self>,
2256            encoder: &mut ___E,
2257            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2258            _: (),
2259        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2260            if let Some(inner) = this {
2261                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2262                ::fidl_next::WireBox::encode_present(out);
2263            } else {
2264                ::fidl_next::WireBox::encode_absent(out);
2265            }
2266
2267            Ok(())
2268        }
2269    }
2270
2271    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreConnectorCreateResponse
2272    where
2273        ___E: ::fidl_next::Encoder + ?Sized,
2274        CapabilityStoreConnectorCreateResponse: ::fidl_next::EncodeRef<___E>,
2275    {
2276        #[inline]
2277        fn encode_option_ref(
2278            this: ::core::option::Option<&Self>,
2279            encoder: &mut ___E,
2280            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2281            _: (),
2282        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2283            if let Some(inner) = this {
2284                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2285                ::fidl_next::WireBox::encode_present(out);
2286            } else {
2287                ::fidl_next::WireBox::encode_absent(out);
2288            }
2289
2290            Ok(())
2291        }
2292    }
2293
2294    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorCreateResponse>
2295        for CapabilityStoreConnectorCreateResponse
2296    {
2297        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2298            crate::wire::CapabilityStoreConnectorCreateResponse,
2299            Self,
2300        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2301
2302        #[inline]
2303        fn from_wire(wire: crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
2304            Self {}
2305        }
2306    }
2307
2308    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorCreateResponse>
2309        for CapabilityStoreConnectorCreateResponse
2310    {
2311        #[inline]
2312        fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorCreateResponse) -> Self {
2313            Self {}
2314        }
2315    }
2316
2317    #[derive(PartialEq, Debug)]
2318    pub struct CapabilityStoreConnectorOpenRequest {
2319        pub id: u64,
2320
2321        pub server_end: ::fidl_next::fuchsia::zx::Channel,
2322    }
2323
2324    impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest {
2325        type Encoded = crate::wire::CapabilityStoreConnectorOpenRequest;
2326    }
2327
2328    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest
2329    where
2330        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2331        ___E: ::fidl_next::fuchsia::HandleEncoder,
2332    {
2333        #[inline]
2334        fn encode(
2335            self,
2336            encoder_: &mut ___E,
2337            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2338            _: (),
2339        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2340            ::fidl_next::munge! {
2341                let Self::Encoded {
2342                    id,
2343                    server_end,
2344
2345                } = out_;
2346            }
2347
2348            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
2349
2350            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2351
2352            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
2353
2354            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
2355
2356            Ok(())
2357        }
2358    }
2359
2360    impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenRequest {
2361        type EncodedOption =
2362            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenRequest>;
2363    }
2364
2365    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenRequest
2366    where
2367        ___E: ::fidl_next::Encoder + ?Sized,
2368        CapabilityStoreConnectorOpenRequest: ::fidl_next::Encode<___E>,
2369    {
2370        #[inline]
2371        fn encode_option(
2372            this: ::core::option::Option<Self>,
2373            encoder: &mut ___E,
2374            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2375            _: (),
2376        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2377            if let Some(inner) = this {
2378                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2379                ::fidl_next::WireBox::encode_present(out);
2380            } else {
2381                ::fidl_next::WireBox::encode_absent(out);
2382            }
2383
2384            Ok(())
2385        }
2386    }
2387
2388    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenRequest>
2389        for CapabilityStoreConnectorOpenRequest
2390    {
2391        #[inline]
2392        fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenRequest) -> Self {
2393            Self {
2394                id: ::fidl_next::FromWire::from_wire(wire.id),
2395
2396                server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
2397            }
2398        }
2399    }
2400
2401    #[derive(PartialEq, Clone, Debug)]
2402    #[repr(C)]
2403    pub struct CapabilityStoreConnectorOpenResponse {}
2404
2405    impl ::fidl_next::Encodable for CapabilityStoreConnectorOpenResponse {
2406        type Encoded = crate::wire::CapabilityStoreConnectorOpenResponse;
2407    }
2408
2409    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenResponse
2410    where
2411        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2412    {
2413        #[inline]
2414        fn encode(
2415            self,
2416            encoder_: &mut ___E,
2417            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2418            _: (),
2419        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2420            *out_ = ::core::mem::MaybeUninit::zeroed();
2421
2422            Ok(())
2423        }
2424    }
2425
2426    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreConnectorOpenResponse
2427    where
2428        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2429    {
2430        #[inline]
2431        fn encode_ref(
2432            &self,
2433            encoder_: &mut ___E,
2434            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2435            _: (),
2436        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2437            ::fidl_next::munge! {
2438                let Self::Encoded {
2439
2440                        _empty,
2441
2442
2443                } = out_;
2444            }
2445
2446            Ok(())
2447        }
2448    }
2449
2450    impl ::fidl_next::EncodableOption for CapabilityStoreConnectorOpenResponse {
2451        type EncodedOption =
2452            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreConnectorOpenResponse>;
2453    }
2454
2455    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreConnectorOpenResponse
2456    where
2457        ___E: ::fidl_next::Encoder + ?Sized,
2458        CapabilityStoreConnectorOpenResponse: ::fidl_next::Encode<___E>,
2459    {
2460        #[inline]
2461        fn encode_option(
2462            this: ::core::option::Option<Self>,
2463            encoder: &mut ___E,
2464            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2465            _: (),
2466        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2467            if let Some(inner) = this {
2468                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2469                ::fidl_next::WireBox::encode_present(out);
2470            } else {
2471                ::fidl_next::WireBox::encode_absent(out);
2472            }
2473
2474            Ok(())
2475        }
2476    }
2477
2478    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreConnectorOpenResponse
2479    where
2480        ___E: ::fidl_next::Encoder + ?Sized,
2481        CapabilityStoreConnectorOpenResponse: ::fidl_next::EncodeRef<___E>,
2482    {
2483        #[inline]
2484        fn encode_option_ref(
2485            this: ::core::option::Option<&Self>,
2486            encoder: &mut ___E,
2487            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2488            _: (),
2489        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2490            if let Some(inner) = this {
2491                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2492                ::fidl_next::WireBox::encode_present(out);
2493            } else {
2494                ::fidl_next::WireBox::encode_absent(out);
2495            }
2496
2497            Ok(())
2498        }
2499    }
2500
2501    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreConnectorOpenResponse>
2502        for CapabilityStoreConnectorOpenResponse
2503    {
2504        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2505            crate::wire::CapabilityStoreConnectorOpenResponse,
2506            Self,
2507        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2508
2509        #[inline]
2510        fn from_wire(wire: crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
2511            Self {}
2512        }
2513    }
2514
2515    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreConnectorOpenResponse>
2516        for CapabilityStoreConnectorOpenResponse
2517    {
2518        #[inline]
2519        fn from_wire_ref(wire: &crate::wire::CapabilityStoreConnectorOpenResponse) -> Self {
2520            Self {}
2521        }
2522    }
2523
2524    #[derive(PartialEq, Clone, Debug)]
2525    #[repr(C)]
2526    pub struct CapabilityStoreDirConnectorCreateResponse {}
2527
2528    impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateResponse {
2529        type Encoded = crate::wire::CapabilityStoreDirConnectorCreateResponse;
2530    }
2531
2532    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateResponse
2533    where
2534        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2535    {
2536        #[inline]
2537        fn encode(
2538            self,
2539            encoder_: &mut ___E,
2540            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2541            _: (),
2542        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2543            *out_ = ::core::mem::MaybeUninit::zeroed();
2544
2545            Ok(())
2546        }
2547    }
2548
2549    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDirConnectorCreateResponse
2550    where
2551        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2552    {
2553        #[inline]
2554        fn encode_ref(
2555            &self,
2556            encoder_: &mut ___E,
2557            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2558            _: (),
2559        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2560            ::fidl_next::munge! {
2561                let Self::Encoded {
2562
2563                        _empty,
2564
2565
2566                } = out_;
2567            }
2568
2569            Ok(())
2570        }
2571    }
2572
2573    impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateResponse {
2574        type EncodedOption =
2575            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateResponse>;
2576    }
2577
2578    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateResponse
2579    where
2580        ___E: ::fidl_next::Encoder + ?Sized,
2581        CapabilityStoreDirConnectorCreateResponse: ::fidl_next::Encode<___E>,
2582    {
2583        #[inline]
2584        fn encode_option(
2585            this: ::core::option::Option<Self>,
2586            encoder: &mut ___E,
2587            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2588            _: (),
2589        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590            if let Some(inner) = this {
2591                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2592                ::fidl_next::WireBox::encode_present(out);
2593            } else {
2594                ::fidl_next::WireBox::encode_absent(out);
2595            }
2596
2597            Ok(())
2598        }
2599    }
2600
2601    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDirConnectorCreateResponse
2602    where
2603        ___E: ::fidl_next::Encoder + ?Sized,
2604        CapabilityStoreDirConnectorCreateResponse: ::fidl_next::EncodeRef<___E>,
2605    {
2606        #[inline]
2607        fn encode_option_ref(
2608            this: ::core::option::Option<&Self>,
2609            encoder: &mut ___E,
2610            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2611            _: (),
2612        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2613            if let Some(inner) = this {
2614                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2615                ::fidl_next::WireBox::encode_present(out);
2616            } else {
2617                ::fidl_next::WireBox::encode_absent(out);
2618            }
2619
2620            Ok(())
2621        }
2622    }
2623
2624    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateResponse>
2625        for CapabilityStoreDirConnectorCreateResponse
2626    {
2627        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2628            crate::wire::CapabilityStoreDirConnectorCreateResponse,
2629            Self,
2630        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2631
2632        #[inline]
2633        fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
2634            Self {}
2635        }
2636    }
2637
2638    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorCreateResponse>
2639        for CapabilityStoreDirConnectorCreateResponse
2640    {
2641        #[inline]
2642        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorCreateResponse) -> Self {
2643            Self {}
2644        }
2645    }
2646
2647    #[derive(PartialEq, Clone, Debug)]
2648    #[repr(C)]
2649    pub struct CapabilityStoreDirConnectorOpenResponse {}
2650
2651    impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenResponse {
2652        type Encoded = crate::wire::CapabilityStoreDirConnectorOpenResponse;
2653    }
2654
2655    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenResponse
2656    where
2657        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2658    {
2659        #[inline]
2660        fn encode(
2661            self,
2662            encoder_: &mut ___E,
2663            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2664            _: (),
2665        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2666            *out_ = ::core::mem::MaybeUninit::zeroed();
2667
2668            Ok(())
2669        }
2670    }
2671
2672    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDirConnectorOpenResponse
2673    where
2674        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2675    {
2676        #[inline]
2677        fn encode_ref(
2678            &self,
2679            encoder_: &mut ___E,
2680            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2681            _: (),
2682        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2683            ::fidl_next::munge! {
2684                let Self::Encoded {
2685
2686                        _empty,
2687
2688
2689                } = out_;
2690            }
2691
2692            Ok(())
2693        }
2694    }
2695
2696    impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenResponse {
2697        type EncodedOption =
2698            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenResponse>;
2699    }
2700
2701    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenResponse
2702    where
2703        ___E: ::fidl_next::Encoder + ?Sized,
2704        CapabilityStoreDirConnectorOpenResponse: ::fidl_next::Encode<___E>,
2705    {
2706        #[inline]
2707        fn encode_option(
2708            this: ::core::option::Option<Self>,
2709            encoder: &mut ___E,
2710            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2711            _: (),
2712        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2713            if let Some(inner) = this {
2714                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2715                ::fidl_next::WireBox::encode_present(out);
2716            } else {
2717                ::fidl_next::WireBox::encode_absent(out);
2718            }
2719
2720            Ok(())
2721        }
2722    }
2723
2724    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDirConnectorOpenResponse
2725    where
2726        ___E: ::fidl_next::Encoder + ?Sized,
2727        CapabilityStoreDirConnectorOpenResponse: ::fidl_next::EncodeRef<___E>,
2728    {
2729        #[inline]
2730        fn encode_option_ref(
2731            this: ::core::option::Option<&Self>,
2732            encoder: &mut ___E,
2733            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2734            _: (),
2735        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2736            if let Some(inner) = this {
2737                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2738                ::fidl_next::WireBox::encode_present(out);
2739            } else {
2740                ::fidl_next::WireBox::encode_absent(out);
2741            }
2742
2743            Ok(())
2744        }
2745    }
2746
2747    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2748        for CapabilityStoreDirConnectorOpenResponse
2749    {
2750        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2751            crate::wire::CapabilityStoreDirConnectorOpenResponse,
2752            Self,
2753        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
2754
2755        #[inline]
2756        fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2757            Self {}
2758        }
2759    }
2760
2761    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDirConnectorOpenResponse>
2762        for CapabilityStoreDirConnectorOpenResponse
2763    {
2764        #[inline]
2765        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDirConnectorOpenResponse) -> Self {
2766            Self {}
2767        }
2768    }
2769
2770    #[derive(PartialEq, Clone, Debug)]
2771    #[repr(C)]
2772    pub struct CapabilityStoreDictionaryCreateRequest {
2773        pub id: u64,
2774    }
2775
2776    impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest {
2777        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2778            Self,
2779            crate::wire::CapabilityStoreDictionaryCreateRequest,
2780        > = unsafe {
2781            ::fidl_next::CopyOptimization::enable_if(
2782                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
2783            )
2784        };
2785
2786        type Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest;
2787    }
2788
2789    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest
2790    where
2791        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2792    {
2793        #[inline]
2794        fn encode(
2795            self,
2796            encoder_: &mut ___E,
2797            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2798            _: (),
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            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2810
2811            Ok(())
2812        }
2813    }
2814
2815    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateRequest
2816    where
2817        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2818    {
2819        #[inline]
2820        fn encode_ref(
2821            &self,
2822            encoder_: &mut ___E,
2823            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2824            _: (),
2825        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2826            ::fidl_next::munge! {
2827                let Self::Encoded {
2828
2829                    id,
2830
2831                } = out_;
2832            }
2833
2834            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
2835
2836            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
2837
2838            Ok(())
2839        }
2840    }
2841
2842    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateRequest {
2843        type EncodedOption =
2844            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCreateRequest>;
2845    }
2846
2847    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateRequest
2848    where
2849        ___E: ::fidl_next::Encoder + ?Sized,
2850        CapabilityStoreDictionaryCreateRequest: ::fidl_next::Encode<___E>,
2851    {
2852        #[inline]
2853        fn encode_option(
2854            this: ::core::option::Option<Self>,
2855            encoder: &mut ___E,
2856            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2857            _: (),
2858        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2859            if let Some(inner) = this {
2860                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2861                ::fidl_next::WireBox::encode_present(out);
2862            } else {
2863                ::fidl_next::WireBox::encode_absent(out);
2864            }
2865
2866            Ok(())
2867        }
2868    }
2869
2870    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateRequest
2871    where
2872        ___E: ::fidl_next::Encoder + ?Sized,
2873        CapabilityStoreDictionaryCreateRequest: ::fidl_next::EncodeRef<___E>,
2874    {
2875        #[inline]
2876        fn encode_option_ref(
2877            this: ::core::option::Option<&Self>,
2878            encoder: &mut ___E,
2879            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2880            _: (),
2881        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2882            if let Some(inner) = this {
2883                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2884                ::fidl_next::WireBox::encode_present(out);
2885            } else {
2886                ::fidl_next::WireBox::encode_absent(out);
2887            }
2888
2889            Ok(())
2890        }
2891    }
2892
2893    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateRequest>
2894        for CapabilityStoreDictionaryCreateRequest
2895    {
2896        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2897            crate::wire::CapabilityStoreDictionaryCreateRequest,
2898            Self,
2899        > = unsafe {
2900            ::fidl_next::CopyOptimization::enable_if(
2901                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
2902                    .is_enabled(),
2903            )
2904        };
2905
2906        #[inline]
2907        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2908            Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
2909        }
2910    }
2911
2912    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateRequest>
2913        for CapabilityStoreDictionaryCreateRequest
2914    {
2915        #[inline]
2916        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateRequest) -> Self {
2917            Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
2918        }
2919    }
2920
2921    #[derive(PartialEq, Clone, Debug)]
2922    #[repr(C)]
2923    pub struct CapabilityStoreDictionaryCreateResponse {}
2924
2925    impl ::fidl_next::Encodable for CapabilityStoreDictionaryCreateResponse {
2926        type Encoded = crate::wire::CapabilityStoreDictionaryCreateResponse;
2927    }
2928
2929    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateResponse
2930    where
2931        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2932    {
2933        #[inline]
2934        fn encode(
2935            self,
2936            encoder_: &mut ___E,
2937            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2938            _: (),
2939        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940            *out_ = ::core::mem::MaybeUninit::zeroed();
2941
2942            Ok(())
2943        }
2944    }
2945
2946    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCreateResponse
2947    where
2948        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2949    {
2950        #[inline]
2951        fn encode_ref(
2952            &self,
2953            encoder_: &mut ___E,
2954            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
2955            _: (),
2956        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2957            ::fidl_next::munge! {
2958                let Self::Encoded {
2959
2960                        _empty,
2961
2962
2963                } = out_;
2964            }
2965
2966            Ok(())
2967        }
2968    }
2969
2970    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCreateResponse {
2971        type EncodedOption =
2972            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCreateResponse>;
2973    }
2974
2975    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCreateResponse
2976    where
2977        ___E: ::fidl_next::Encoder + ?Sized,
2978        CapabilityStoreDictionaryCreateResponse: ::fidl_next::Encode<___E>,
2979    {
2980        #[inline]
2981        fn encode_option(
2982            this: ::core::option::Option<Self>,
2983            encoder: &mut ___E,
2984            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
2985            _: (),
2986        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2987            if let Some(inner) = this {
2988                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
2989                ::fidl_next::WireBox::encode_present(out);
2990            } else {
2991                ::fidl_next::WireBox::encode_absent(out);
2992            }
2993
2994            Ok(())
2995        }
2996    }
2997
2998    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCreateResponse
2999    where
3000        ___E: ::fidl_next::Encoder + ?Sized,
3001        CapabilityStoreDictionaryCreateResponse: ::fidl_next::EncodeRef<___E>,
3002    {
3003        #[inline]
3004        fn encode_option_ref(
3005            this: ::core::option::Option<&Self>,
3006            encoder: &mut ___E,
3007            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3008            _: (),
3009        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3010            if let Some(inner) = this {
3011                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3012                ::fidl_next::WireBox::encode_present(out);
3013            } else {
3014                ::fidl_next::WireBox::encode_absent(out);
3015            }
3016
3017            Ok(())
3018        }
3019    }
3020
3021    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCreateResponse>
3022        for CapabilityStoreDictionaryCreateResponse
3023    {
3024        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3025            crate::wire::CapabilityStoreDictionaryCreateResponse,
3026            Self,
3027        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3028
3029        #[inline]
3030        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
3031            Self {}
3032        }
3033    }
3034
3035    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCreateResponse>
3036        for CapabilityStoreDictionaryCreateResponse
3037    {
3038        #[inline]
3039        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCreateResponse) -> Self {
3040            Self {}
3041        }
3042    }
3043
3044    #[derive(PartialEq, Debug)]
3045    pub struct CapabilityStoreDictionaryLegacyImportRequest {
3046        pub id: u64,
3047
3048        pub client_end: ::fidl_next::fuchsia::zx::Channel,
3049    }
3050
3051    impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest {
3052        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
3053    }
3054
3055    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportRequest
3056    where
3057        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3058        ___E: ::fidl_next::fuchsia::HandleEncoder,
3059    {
3060        #[inline]
3061        fn encode(
3062            self,
3063            encoder_: &mut ___E,
3064            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3065            _: (),
3066        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067            ::fidl_next::munge! {
3068                let Self::Encoded {
3069                    id,
3070                    client_end,
3071
3072                } = out_;
3073            }
3074
3075            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3076
3077            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3078
3079            ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
3080
3081            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(client_end.as_mut_ptr()) };
3082
3083            Ok(())
3084        }
3085    }
3086
3087    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportRequest {
3088        type EncodedOption = ::fidl_next::WireBox<
3089            'static,
3090            crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
3091        >;
3092    }
3093
3094    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportRequest
3095    where
3096        ___E: ::fidl_next::Encoder + ?Sized,
3097        CapabilityStoreDictionaryLegacyImportRequest: ::fidl_next::Encode<___E>,
3098    {
3099        #[inline]
3100        fn encode_option(
3101            this: ::core::option::Option<Self>,
3102            encoder: &mut ___E,
3103            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3104            _: (),
3105        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3106            if let Some(inner) = this {
3107                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3108                ::fidl_next::WireBox::encode_present(out);
3109            } else {
3110                ::fidl_next::WireBox::encode_absent(out);
3111            }
3112
3113            Ok(())
3114        }
3115    }
3116
3117    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportRequest>
3118        for CapabilityStoreDictionaryLegacyImportRequest
3119    {
3120        #[inline]
3121        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
3122            Self {
3123                id: ::fidl_next::FromWire::from_wire(wire.id),
3124
3125                client_end: ::fidl_next::FromWire::from_wire(wire.client_end),
3126            }
3127        }
3128    }
3129
3130    #[derive(PartialEq, Clone, Debug)]
3131    #[repr(C)]
3132    pub struct CapabilityStoreDictionaryLegacyImportResponse {}
3133
3134    impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportResponse {
3135        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportResponse;
3136    }
3137
3138    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyImportResponse
3139    where
3140        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3141    {
3142        #[inline]
3143        fn encode(
3144            self,
3145            encoder_: &mut ___E,
3146            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3147            _: (),
3148        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3149            *out_ = ::core::mem::MaybeUninit::zeroed();
3150
3151            Ok(())
3152        }
3153    }
3154
3155    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryLegacyImportResponse
3156    where
3157        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3158    {
3159        #[inline]
3160        fn encode_ref(
3161            &self,
3162            encoder_: &mut ___E,
3163            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3164            _: (),
3165        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3166            ::fidl_next::munge! {
3167                let Self::Encoded {
3168
3169                        _empty,
3170
3171
3172                } = out_;
3173            }
3174
3175            Ok(())
3176        }
3177    }
3178
3179    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyImportResponse {
3180        type EncodedOption = ::fidl_next::WireBox<
3181            'static,
3182            crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3183        >;
3184    }
3185
3186    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyImportResponse
3187    where
3188        ___E: ::fidl_next::Encoder + ?Sized,
3189        CapabilityStoreDictionaryLegacyImportResponse: ::fidl_next::Encode<___E>,
3190    {
3191        #[inline]
3192        fn encode_option(
3193            this: ::core::option::Option<Self>,
3194            encoder: &mut ___E,
3195            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3196            _: (),
3197        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3198            if let Some(inner) = this {
3199                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3200                ::fidl_next::WireBox::encode_present(out);
3201            } else {
3202                ::fidl_next::WireBox::encode_absent(out);
3203            }
3204
3205            Ok(())
3206        }
3207    }
3208
3209    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E>
3210        for CapabilityStoreDictionaryLegacyImportResponse
3211    where
3212        ___E: ::fidl_next::Encoder + ?Sized,
3213        CapabilityStoreDictionaryLegacyImportResponse: ::fidl_next::EncodeRef<___E>,
3214    {
3215        #[inline]
3216        fn encode_option_ref(
3217            this: ::core::option::Option<&Self>,
3218            encoder: &mut ___E,
3219            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3220            _: (),
3221        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3222            if let Some(inner) = this {
3223                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3224                ::fidl_next::WireBox::encode_present(out);
3225            } else {
3226                ::fidl_next::WireBox::encode_absent(out);
3227            }
3228
3229            Ok(())
3230        }
3231    }
3232
3233    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
3234        for CapabilityStoreDictionaryLegacyImportResponse
3235    {
3236        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3237            crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3238            Self,
3239        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3240
3241        #[inline]
3242        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyImportResponse) -> Self {
3243            Self {}
3244        }
3245    }
3246
3247    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyImportResponse>
3248        for CapabilityStoreDictionaryLegacyImportResponse
3249    {
3250        #[inline]
3251        fn from_wire_ref(
3252            wire: &crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
3253        ) -> Self {
3254            Self {}
3255        }
3256    }
3257
3258    #[derive(PartialEq, Debug)]
3259    pub struct CapabilityStoreDictionaryLegacyExportRequest {
3260        pub id: u64,
3261
3262        pub server_end: ::fidl_next::fuchsia::zx::Channel,
3263    }
3264
3265    impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest {
3266        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
3267    }
3268
3269    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportRequest
3270    where
3271        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3272        ___E: ::fidl_next::fuchsia::HandleEncoder,
3273    {
3274        #[inline]
3275        fn encode(
3276            self,
3277            encoder_: &mut ___E,
3278            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3279            _: (),
3280        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3281            ::fidl_next::munge! {
3282                let Self::Encoded {
3283                    id,
3284                    server_end,
3285
3286                } = out_;
3287            }
3288
3289            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3290
3291            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3292
3293            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
3294
3295            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
3296
3297            Ok(())
3298        }
3299    }
3300
3301    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportRequest {
3302        type EncodedOption = ::fidl_next::WireBox<
3303            'static,
3304            crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
3305        >;
3306    }
3307
3308    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportRequest
3309    where
3310        ___E: ::fidl_next::Encoder + ?Sized,
3311        CapabilityStoreDictionaryLegacyExportRequest: ::fidl_next::Encode<___E>,
3312    {
3313        #[inline]
3314        fn encode_option(
3315            this: ::core::option::Option<Self>,
3316            encoder: &mut ___E,
3317            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3318            _: (),
3319        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3320            if let Some(inner) = this {
3321                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3322                ::fidl_next::WireBox::encode_present(out);
3323            } else {
3324                ::fidl_next::WireBox::encode_absent(out);
3325            }
3326
3327            Ok(())
3328        }
3329    }
3330
3331    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportRequest>
3332        for CapabilityStoreDictionaryLegacyExportRequest
3333    {
3334        #[inline]
3335        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
3336            Self {
3337                id: ::fidl_next::FromWire::from_wire(wire.id),
3338
3339                server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
3340            }
3341        }
3342    }
3343
3344    #[derive(PartialEq, Clone, Debug)]
3345    #[repr(C)]
3346    pub struct CapabilityStoreDictionaryLegacyExportResponse {}
3347
3348    impl ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportResponse {
3349        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportResponse;
3350    }
3351
3352    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryLegacyExportResponse
3353    where
3354        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3355    {
3356        #[inline]
3357        fn encode(
3358            self,
3359            encoder_: &mut ___E,
3360            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3361            _: (),
3362        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3363            *out_ = ::core::mem::MaybeUninit::zeroed();
3364
3365            Ok(())
3366        }
3367    }
3368
3369    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryLegacyExportResponse
3370    where
3371        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3372    {
3373        #[inline]
3374        fn encode_ref(
3375            &self,
3376            encoder_: &mut ___E,
3377            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3378            _: (),
3379        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3380            ::fidl_next::munge! {
3381                let Self::Encoded {
3382
3383                        _empty,
3384
3385
3386                } = out_;
3387            }
3388
3389            Ok(())
3390        }
3391    }
3392
3393    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryLegacyExportResponse {
3394        type EncodedOption = ::fidl_next::WireBox<
3395            'static,
3396            crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3397        >;
3398    }
3399
3400    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryLegacyExportResponse
3401    where
3402        ___E: ::fidl_next::Encoder + ?Sized,
3403        CapabilityStoreDictionaryLegacyExportResponse: ::fidl_next::Encode<___E>,
3404    {
3405        #[inline]
3406        fn encode_option(
3407            this: ::core::option::Option<Self>,
3408            encoder: &mut ___E,
3409            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3410            _: (),
3411        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3412            if let Some(inner) = this {
3413                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3414                ::fidl_next::WireBox::encode_present(out);
3415            } else {
3416                ::fidl_next::WireBox::encode_absent(out);
3417            }
3418
3419            Ok(())
3420        }
3421    }
3422
3423    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E>
3424        for CapabilityStoreDictionaryLegacyExportResponse
3425    where
3426        ___E: ::fidl_next::Encoder + ?Sized,
3427        CapabilityStoreDictionaryLegacyExportResponse: ::fidl_next::EncodeRef<___E>,
3428    {
3429        #[inline]
3430        fn encode_option_ref(
3431            this: ::core::option::Option<&Self>,
3432            encoder: &mut ___E,
3433            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3434            _: (),
3435        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3436            if let Some(inner) = this {
3437                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3438                ::fidl_next::WireBox::encode_present(out);
3439            } else {
3440                ::fidl_next::WireBox::encode_absent(out);
3441            }
3442
3443            Ok(())
3444        }
3445    }
3446
3447    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
3448        for CapabilityStoreDictionaryLegacyExportResponse
3449    {
3450        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3451            crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3452            Self,
3453        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3454
3455        #[inline]
3456        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryLegacyExportResponse) -> Self {
3457            Self {}
3458        }
3459    }
3460
3461    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryLegacyExportResponse>
3462        for CapabilityStoreDictionaryLegacyExportResponse
3463    {
3464        #[inline]
3465        fn from_wire_ref(
3466            wire: &crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
3467        ) -> Self {
3468            Self {}
3469        }
3470    }
3471
3472    #[doc = " The key of a [`DictionaryItem`]. The constraints for valid keys are documented at\n https://fuchsia.dev/reference/cml#names.\n"]
3473    pub type DictionaryKey = ::std::string::String;
3474
3475    #[doc = " A key-value pair in a [`DictionaryRef`].\n"]
3476    #[derive(PartialEq, Clone, Debug)]
3477    pub struct DictionaryItem {
3478        pub key: ::std::string::String,
3479
3480        pub value: u64,
3481    }
3482
3483    impl ::fidl_next::Encodable for DictionaryItem {
3484        type Encoded = crate::wire::DictionaryItem<'static>;
3485    }
3486
3487    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryItem
3488    where
3489        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3490        ___E: ::fidl_next::Encoder,
3491    {
3492        #[inline]
3493        fn encode(
3494            self,
3495            encoder_: &mut ___E,
3496            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3497            _: (),
3498        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3499            ::fidl_next::munge! {
3500                let Self::Encoded {
3501                    key,
3502                    value,
3503
3504                } = out_;
3505            }
3506
3507            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3508
3509            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3510            ::fidl_next::Constrained::validate(_field, 255)?;
3511
3512            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
3513
3514            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
3515
3516            Ok(())
3517        }
3518    }
3519
3520    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryItem
3521    where
3522        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3523        ___E: ::fidl_next::Encoder,
3524    {
3525        #[inline]
3526        fn encode_ref(
3527            &self,
3528            encoder_: &mut ___E,
3529            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3530            _: (),
3531        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3532            ::fidl_next::munge! {
3533                let Self::Encoded {
3534
3535                    key,
3536                    value,
3537
3538                } = out_;
3539            }
3540
3541            ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
3542
3543            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3544            ::fidl_next::Constrained::validate(_field, 255)?;
3545
3546            ::fidl_next::EncodeRef::encode_ref(&self.value, encoder_, value, ())?;
3547
3548            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
3549
3550            Ok(())
3551        }
3552    }
3553
3554    impl ::fidl_next::EncodableOption for DictionaryItem {
3555        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DictionaryItem<'static>>;
3556    }
3557
3558    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryItem
3559    where
3560        ___E: ::fidl_next::Encoder + ?Sized,
3561        DictionaryItem: ::fidl_next::Encode<___E>,
3562    {
3563        #[inline]
3564        fn encode_option(
3565            this: ::core::option::Option<Self>,
3566            encoder: &mut ___E,
3567            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3568            _: (),
3569        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3570            if let Some(inner) = this {
3571                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3572                ::fidl_next::WireBox::encode_present(out);
3573            } else {
3574                ::fidl_next::WireBox::encode_absent(out);
3575            }
3576
3577            Ok(())
3578        }
3579    }
3580
3581    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryItem
3582    where
3583        ___E: ::fidl_next::Encoder + ?Sized,
3584        DictionaryItem: ::fidl_next::EncodeRef<___E>,
3585    {
3586        #[inline]
3587        fn encode_option_ref(
3588            this: ::core::option::Option<&Self>,
3589            encoder: &mut ___E,
3590            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3591            _: (),
3592        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3593            if let Some(inner) = this {
3594                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3595                ::fidl_next::WireBox::encode_present(out);
3596            } else {
3597                ::fidl_next::WireBox::encode_absent(out);
3598            }
3599
3600            Ok(())
3601        }
3602    }
3603
3604    impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryItem<'de>> for DictionaryItem {
3605        #[inline]
3606        fn from_wire(wire: crate::wire::DictionaryItem<'de>) -> Self {
3607            Self {
3608                key: ::fidl_next::FromWire::from_wire(wire.key),
3609
3610                value: ::fidl_next::FromWire::from_wire(wire.value),
3611            }
3612        }
3613    }
3614
3615    impl<'de> ::fidl_next::FromWireRef<crate::wire::DictionaryItem<'de>> for DictionaryItem {
3616        #[inline]
3617        fn from_wire_ref(wire: &crate::wire::DictionaryItem<'de>) -> Self {
3618            Self {
3619                key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
3620
3621                value: ::fidl_next::FromWireRef::from_wire_ref(&wire.value),
3622            }
3623        }
3624    }
3625
3626    #[derive(PartialEq, Clone, Debug)]
3627    pub struct CapabilityStoreDictionaryInsertRequest {
3628        pub id: u64,
3629
3630        pub item: crate::natural::DictionaryItem,
3631    }
3632
3633    impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest {
3634        type Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
3635    }
3636
3637    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertRequest
3638    where
3639        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3640        ___E: ::fidl_next::Encoder,
3641    {
3642        #[inline]
3643        fn encode(
3644            self,
3645            encoder_: &mut ___E,
3646            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3647            _: (),
3648        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3649            ::fidl_next::munge! {
3650                let Self::Encoded {
3651                    id,
3652                    item,
3653
3654                } = out_;
3655            }
3656
3657            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3658
3659            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3660
3661            ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
3662
3663            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
3664
3665            Ok(())
3666        }
3667    }
3668
3669    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertRequest
3670    where
3671        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3672        ___E: ::fidl_next::Encoder,
3673    {
3674        #[inline]
3675        fn encode_ref(
3676            &self,
3677            encoder_: &mut ___E,
3678            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3679            _: (),
3680        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3681            ::fidl_next::munge! {
3682                let Self::Encoded {
3683
3684                    id,
3685                    item,
3686
3687                } = out_;
3688            }
3689
3690            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
3691
3692            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3693
3694            ::fidl_next::EncodeRef::encode_ref(&self.item, encoder_, item, ())?;
3695
3696            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(item.as_mut_ptr()) };
3697
3698            Ok(())
3699        }
3700    }
3701
3702    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertRequest {
3703        type EncodedOption = ::fidl_next::WireBox<
3704            'static,
3705            crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
3706        >;
3707    }
3708
3709    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertRequest
3710    where
3711        ___E: ::fidl_next::Encoder + ?Sized,
3712        CapabilityStoreDictionaryInsertRequest: ::fidl_next::Encode<___E>,
3713    {
3714        #[inline]
3715        fn encode_option(
3716            this: ::core::option::Option<Self>,
3717            encoder: &mut ___E,
3718            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3719            _: (),
3720        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3721            if let Some(inner) = this {
3722                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3723                ::fidl_next::WireBox::encode_present(out);
3724            } else {
3725                ::fidl_next::WireBox::encode_absent(out);
3726            }
3727
3728            Ok(())
3729        }
3730    }
3731
3732    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertRequest
3733    where
3734        ___E: ::fidl_next::Encoder + ?Sized,
3735        CapabilityStoreDictionaryInsertRequest: ::fidl_next::EncodeRef<___E>,
3736    {
3737        #[inline]
3738        fn encode_option_ref(
3739            this: ::core::option::Option<&Self>,
3740            encoder: &mut ___E,
3741            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3742            _: (),
3743        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3744            if let Some(inner) = this {
3745                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3746                ::fidl_next::WireBox::encode_present(out);
3747            } else {
3748                ::fidl_next::WireBox::encode_absent(out);
3749            }
3750
3751            Ok(())
3752        }
3753    }
3754
3755    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3756        for CapabilityStoreDictionaryInsertRequest
3757    {
3758        #[inline]
3759        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3760            Self {
3761                id: ::fidl_next::FromWire::from_wire(wire.id),
3762
3763                item: ::fidl_next::FromWire::from_wire(wire.item),
3764            }
3765        }
3766    }
3767
3768    impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertRequest<'de>>
3769        for CapabilityStoreDictionaryInsertRequest
3770    {
3771        #[inline]
3772        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertRequest<'de>) -> Self {
3773            Self {
3774                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
3775
3776                item: ::fidl_next::FromWireRef::from_wire_ref(&wire.item),
3777            }
3778        }
3779    }
3780
3781    #[derive(PartialEq, Clone, Debug)]
3782    #[repr(C)]
3783    pub struct CapabilityStoreDictionaryInsertResponse {}
3784
3785    impl ::fidl_next::Encodable for CapabilityStoreDictionaryInsertResponse {
3786        type Encoded = crate::wire::CapabilityStoreDictionaryInsertResponse;
3787    }
3788
3789    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryInsertResponse
3790    where
3791        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3792    {
3793        #[inline]
3794        fn encode(
3795            self,
3796            encoder_: &mut ___E,
3797            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3798            _: (),
3799        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3800            *out_ = ::core::mem::MaybeUninit::zeroed();
3801
3802            Ok(())
3803        }
3804    }
3805
3806    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryInsertResponse
3807    where
3808        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3809    {
3810        #[inline]
3811        fn encode_ref(
3812            &self,
3813            encoder_: &mut ___E,
3814            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3815            _: (),
3816        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3817            ::fidl_next::munge! {
3818                let Self::Encoded {
3819
3820                        _empty,
3821
3822
3823                } = out_;
3824            }
3825
3826            Ok(())
3827        }
3828    }
3829
3830    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryInsertResponse {
3831        type EncodedOption =
3832            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryInsertResponse>;
3833    }
3834
3835    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryInsertResponse
3836    where
3837        ___E: ::fidl_next::Encoder + ?Sized,
3838        CapabilityStoreDictionaryInsertResponse: ::fidl_next::Encode<___E>,
3839    {
3840        #[inline]
3841        fn encode_option(
3842            this: ::core::option::Option<Self>,
3843            encoder: &mut ___E,
3844            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3845            _: (),
3846        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3847            if let Some(inner) = this {
3848                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3849                ::fidl_next::WireBox::encode_present(out);
3850            } else {
3851                ::fidl_next::WireBox::encode_absent(out);
3852            }
3853
3854            Ok(())
3855        }
3856    }
3857
3858    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryInsertResponse
3859    where
3860        ___E: ::fidl_next::Encoder + ?Sized,
3861        CapabilityStoreDictionaryInsertResponse: ::fidl_next::EncodeRef<___E>,
3862    {
3863        #[inline]
3864        fn encode_option_ref(
3865            this: ::core::option::Option<&Self>,
3866            encoder: &mut ___E,
3867            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
3868            _: (),
3869        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3870            if let Some(inner) = this {
3871                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
3872                ::fidl_next::WireBox::encode_present(out);
3873            } else {
3874                ::fidl_next::WireBox::encode_absent(out);
3875            }
3876
3877            Ok(())
3878        }
3879    }
3880
3881    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryInsertResponse>
3882        for CapabilityStoreDictionaryInsertResponse
3883    {
3884        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3885            crate::wire::CapabilityStoreDictionaryInsertResponse,
3886            Self,
3887        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
3888
3889        #[inline]
3890        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3891            Self {}
3892        }
3893    }
3894
3895    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryInsertResponse>
3896        for CapabilityStoreDictionaryInsertResponse
3897    {
3898        #[inline]
3899        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryInsertResponse) -> Self {
3900            Self {}
3901        }
3902    }
3903
3904    #[derive(PartialEq, Clone, Debug)]
3905    pub struct CapabilityStoreDictionaryGetRequest {
3906        pub id: u64,
3907
3908        pub key: ::std::string::String,
3909
3910        pub dest_id: u64,
3911    }
3912
3913    impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest {
3914        type Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
3915    }
3916
3917    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetRequest
3918    where
3919        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3920        ___E: ::fidl_next::Encoder,
3921    {
3922        #[inline]
3923        fn encode(
3924            self,
3925            encoder_: &mut ___E,
3926            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3927            _: (),
3928        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3929            ::fidl_next::munge! {
3930                let Self::Encoded {
3931                    id,
3932                    key,
3933                    dest_id,
3934
3935                } = out_;
3936            }
3937
3938            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
3939
3940            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3941
3942            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
3943
3944            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3945            ::fidl_next::Constrained::validate(_field, 255)?;
3946
3947            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
3948
3949            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3950
3951            Ok(())
3952        }
3953    }
3954
3955    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetRequest
3956    where
3957        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3958        ___E: ::fidl_next::Encoder,
3959    {
3960        #[inline]
3961        fn encode_ref(
3962            &self,
3963            encoder_: &mut ___E,
3964            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
3965            _: (),
3966        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3967            ::fidl_next::munge! {
3968                let Self::Encoded {
3969
3970                    id,
3971                    key,
3972                    dest_id,
3973
3974                } = out_;
3975            }
3976
3977            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
3978
3979            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3980
3981            ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
3982
3983            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
3984            ::fidl_next::Constrained::validate(_field, 255)?;
3985
3986            ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
3987
3988            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
3989
3990            Ok(())
3991        }
3992    }
3993
3994    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetRequest {
3995        type EncodedOption = ::fidl_next::WireBox<
3996            'static,
3997            crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
3998        >;
3999    }
4000
4001    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetRequest
4002    where
4003        ___E: ::fidl_next::Encoder + ?Sized,
4004        CapabilityStoreDictionaryGetRequest: ::fidl_next::Encode<___E>,
4005    {
4006        #[inline]
4007        fn encode_option(
4008            this: ::core::option::Option<Self>,
4009            encoder: &mut ___E,
4010            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4011            _: (),
4012        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4013            if let Some(inner) = this {
4014                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4015                ::fidl_next::WireBox::encode_present(out);
4016            } else {
4017                ::fidl_next::WireBox::encode_absent(out);
4018            }
4019
4020            Ok(())
4021        }
4022    }
4023
4024    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetRequest
4025    where
4026        ___E: ::fidl_next::Encoder + ?Sized,
4027        CapabilityStoreDictionaryGetRequest: ::fidl_next::EncodeRef<___E>,
4028    {
4029        #[inline]
4030        fn encode_option_ref(
4031            this: ::core::option::Option<&Self>,
4032            encoder: &mut ___E,
4033            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4034            _: (),
4035        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4036            if let Some(inner) = this {
4037                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4038                ::fidl_next::WireBox::encode_present(out);
4039            } else {
4040                ::fidl_next::WireBox::encode_absent(out);
4041            }
4042
4043            Ok(())
4044        }
4045    }
4046
4047    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
4048        for CapabilityStoreDictionaryGetRequest
4049    {
4050        #[inline]
4051        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
4052            Self {
4053                id: ::fidl_next::FromWire::from_wire(wire.id),
4054
4055                key: ::fidl_next::FromWire::from_wire(wire.key),
4056
4057                dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4058            }
4059        }
4060    }
4061
4062    impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetRequest<'de>>
4063        for CapabilityStoreDictionaryGetRequest
4064    {
4065        #[inline]
4066        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetRequest<'de>) -> Self {
4067            Self {
4068                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4069
4070                key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4071
4072                dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4073            }
4074        }
4075    }
4076
4077    #[derive(PartialEq, Clone, Debug)]
4078    #[repr(C)]
4079    pub struct CapabilityStoreDictionaryGetResponse {}
4080
4081    impl ::fidl_next::Encodable for CapabilityStoreDictionaryGetResponse {
4082        type Encoded = crate::wire::CapabilityStoreDictionaryGetResponse;
4083    }
4084
4085    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryGetResponse
4086    where
4087        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4088    {
4089        #[inline]
4090        fn encode(
4091            self,
4092            encoder_: &mut ___E,
4093            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4094            _: (),
4095        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4096            *out_ = ::core::mem::MaybeUninit::zeroed();
4097
4098            Ok(())
4099        }
4100    }
4101
4102    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryGetResponse
4103    where
4104        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4105    {
4106        #[inline]
4107        fn encode_ref(
4108            &self,
4109            encoder_: &mut ___E,
4110            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4111            _: (),
4112        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4113            ::fidl_next::munge! {
4114                let Self::Encoded {
4115
4116                        _empty,
4117
4118
4119                } = out_;
4120            }
4121
4122            Ok(())
4123        }
4124    }
4125
4126    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryGetResponse {
4127        type EncodedOption =
4128            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryGetResponse>;
4129    }
4130
4131    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryGetResponse
4132    where
4133        ___E: ::fidl_next::Encoder + ?Sized,
4134        CapabilityStoreDictionaryGetResponse: ::fidl_next::Encode<___E>,
4135    {
4136        #[inline]
4137        fn encode_option(
4138            this: ::core::option::Option<Self>,
4139            encoder: &mut ___E,
4140            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4141            _: (),
4142        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4143            if let Some(inner) = this {
4144                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4145                ::fidl_next::WireBox::encode_present(out);
4146            } else {
4147                ::fidl_next::WireBox::encode_absent(out);
4148            }
4149
4150            Ok(())
4151        }
4152    }
4153
4154    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryGetResponse
4155    where
4156        ___E: ::fidl_next::Encoder + ?Sized,
4157        CapabilityStoreDictionaryGetResponse: ::fidl_next::EncodeRef<___E>,
4158    {
4159        #[inline]
4160        fn encode_option_ref(
4161            this: ::core::option::Option<&Self>,
4162            encoder: &mut ___E,
4163            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4164            _: (),
4165        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4166            if let Some(inner) = this {
4167                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4168                ::fidl_next::WireBox::encode_present(out);
4169            } else {
4170                ::fidl_next::WireBox::encode_absent(out);
4171            }
4172
4173            Ok(())
4174        }
4175    }
4176
4177    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryGetResponse>
4178        for CapabilityStoreDictionaryGetResponse
4179    {
4180        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4181            crate::wire::CapabilityStoreDictionaryGetResponse,
4182            Self,
4183        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4184
4185        #[inline]
4186        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
4187            Self {}
4188        }
4189    }
4190
4191    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryGetResponse>
4192        for CapabilityStoreDictionaryGetResponse
4193    {
4194        #[inline]
4195        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryGetResponse) -> Self {
4196            Self {}
4197        }
4198    }
4199
4200    #[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"]
4201    #[derive(PartialEq, Clone, Debug)]
4202    #[repr(C)]
4203    pub struct WrappedCapabilityId {
4204        pub id: u64,
4205    }
4206
4207    impl ::fidl_next::Encodable for WrappedCapabilityId {
4208        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4209            Self,
4210            crate::wire::WrappedCapabilityId,
4211        > = unsafe {
4212            ::fidl_next::CopyOptimization::enable_if(
4213                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4214            )
4215        };
4216
4217        type Encoded = crate::wire::WrappedCapabilityId;
4218    }
4219
4220    unsafe impl<___E> ::fidl_next::Encode<___E> for WrappedCapabilityId
4221    where
4222        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4223    {
4224        #[inline]
4225        fn encode(
4226            self,
4227            encoder_: &mut ___E,
4228            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4229            _: (),
4230        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4231            ::fidl_next::munge! {
4232                let Self::Encoded {
4233                    id,
4234
4235                } = out_;
4236            }
4237
4238            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4239
4240            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4241
4242            Ok(())
4243        }
4244    }
4245
4246    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for WrappedCapabilityId
4247    where
4248        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4249    {
4250        #[inline]
4251        fn encode_ref(
4252            &self,
4253            encoder_: &mut ___E,
4254            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4255            _: (),
4256        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4257            ::fidl_next::munge! {
4258                let Self::Encoded {
4259
4260                    id,
4261
4262                } = out_;
4263            }
4264
4265            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4266
4267            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4268
4269            Ok(())
4270        }
4271    }
4272
4273    impl ::fidl_next::EncodableOption for WrappedCapabilityId {
4274        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>;
4275    }
4276
4277    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for WrappedCapabilityId
4278    where
4279        ___E: ::fidl_next::Encoder + ?Sized,
4280        WrappedCapabilityId: ::fidl_next::Encode<___E>,
4281    {
4282        #[inline]
4283        fn encode_option(
4284            this: ::core::option::Option<Self>,
4285            encoder: &mut ___E,
4286            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4287            _: (),
4288        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4289            if let Some(inner) = this {
4290                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4291                ::fidl_next::WireBox::encode_present(out);
4292            } else {
4293                ::fidl_next::WireBox::encode_absent(out);
4294            }
4295
4296            Ok(())
4297        }
4298    }
4299
4300    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for WrappedCapabilityId
4301    where
4302        ___E: ::fidl_next::Encoder + ?Sized,
4303        WrappedCapabilityId: ::fidl_next::EncodeRef<___E>,
4304    {
4305        #[inline]
4306        fn encode_option_ref(
4307            this: ::core::option::Option<&Self>,
4308            encoder: &mut ___E,
4309            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4310            _: (),
4311        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4312            if let Some(inner) = this {
4313                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4314                ::fidl_next::WireBox::encode_present(out);
4315            } else {
4316                ::fidl_next::WireBox::encode_absent(out);
4317            }
4318
4319            Ok(())
4320        }
4321    }
4322
4323    impl ::fidl_next::FromWire<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
4324        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4325            crate::wire::WrappedCapabilityId,
4326            Self,
4327        > = unsafe {
4328            ::fidl_next::CopyOptimization::enable_if(
4329                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4330                    .is_enabled(),
4331            )
4332        };
4333
4334        #[inline]
4335        fn from_wire(wire: crate::wire::WrappedCapabilityId) -> Self {
4336            Self { id: ::fidl_next::FromWire::from_wire(wire.id) }
4337        }
4338    }
4339
4340    impl ::fidl_next::FromWireRef<crate::wire::WrappedCapabilityId> for WrappedCapabilityId {
4341        #[inline]
4342        fn from_wire_ref(wire: &crate::wire::WrappedCapabilityId) -> Self {
4343            Self { id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id) }
4344        }
4345    }
4346
4347    pub type WrappedNewCapabilityId = crate::natural::WrappedCapabilityId;
4348
4349    #[derive(PartialEq, Clone, Debug)]
4350    pub struct CapabilityStoreDictionaryRemoveRequest {
4351        pub id: u64,
4352
4353        pub key: ::std::string::String,
4354
4355        pub dest_id: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
4356    }
4357
4358    impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest {
4359        type Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
4360    }
4361
4362    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveRequest
4363    where
4364        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4365        ___E: ::fidl_next::Encoder,
4366    {
4367        #[inline]
4368        fn encode(
4369            self,
4370            encoder_: &mut ___E,
4371            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4372            _: (),
4373        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4374            ::fidl_next::munge! {
4375                let Self::Encoded {
4376                    id,
4377                    key,
4378                    dest_id,
4379
4380                } = out_;
4381            }
4382
4383            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4384
4385            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4386
4387            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
4388
4389            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
4390            ::fidl_next::Constrained::validate(_field, 255)?;
4391
4392            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4393
4394            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4395
4396            Ok(())
4397        }
4398    }
4399
4400    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveRequest
4401    where
4402        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4403        ___E: ::fidl_next::Encoder,
4404    {
4405        #[inline]
4406        fn encode_ref(
4407            &self,
4408            encoder_: &mut ___E,
4409            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4410            _: (),
4411        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4412            ::fidl_next::munge! {
4413                let Self::Encoded {
4414
4415                    id,
4416                    key,
4417                    dest_id,
4418
4419                } = out_;
4420            }
4421
4422            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4423
4424            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4425
4426            ::fidl_next::EncodeRef::encode_ref(&self.key, encoder_, key, 255)?;
4427
4428            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
4429            ::fidl_next::Constrained::validate(_field, 255)?;
4430
4431            ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
4432
4433            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4434
4435            Ok(())
4436        }
4437    }
4438
4439    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveRequest {
4440        type EncodedOption = ::fidl_next::WireBox<
4441            'static,
4442            crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
4443        >;
4444    }
4445
4446    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveRequest
4447    where
4448        ___E: ::fidl_next::Encoder + ?Sized,
4449        CapabilityStoreDictionaryRemoveRequest: ::fidl_next::Encode<___E>,
4450    {
4451        #[inline]
4452        fn encode_option(
4453            this: ::core::option::Option<Self>,
4454            encoder: &mut ___E,
4455            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4456            _: (),
4457        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4458            if let Some(inner) = this {
4459                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4460                ::fidl_next::WireBox::encode_present(out);
4461            } else {
4462                ::fidl_next::WireBox::encode_absent(out);
4463            }
4464
4465            Ok(())
4466        }
4467    }
4468
4469    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveRequest
4470    where
4471        ___E: ::fidl_next::Encoder + ?Sized,
4472        CapabilityStoreDictionaryRemoveRequest: ::fidl_next::EncodeRef<___E>,
4473    {
4474        #[inline]
4475        fn encode_option_ref(
4476            this: ::core::option::Option<&Self>,
4477            encoder: &mut ___E,
4478            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4479            _: (),
4480        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4481            if let Some(inner) = this {
4482                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4483                ::fidl_next::WireBox::encode_present(out);
4484            } else {
4485                ::fidl_next::WireBox::encode_absent(out);
4486            }
4487
4488            Ok(())
4489        }
4490    }
4491
4492    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
4493        for CapabilityStoreDictionaryRemoveRequest
4494    {
4495        #[inline]
4496        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4497            Self {
4498                id: ::fidl_next::FromWire::from_wire(wire.id),
4499
4500                key: ::fidl_next::FromWire::from_wire(wire.key),
4501
4502                dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4503            }
4504        }
4505    }
4506
4507    impl<'de> ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>>
4508        for CapabilityStoreDictionaryRemoveRequest
4509    {
4510        #[inline]
4511        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveRequest<'de>) -> Self {
4512            Self {
4513                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4514
4515                key: ::fidl_next::FromWireRef::from_wire_ref(&wire.key),
4516
4517                dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4518            }
4519        }
4520    }
4521
4522    #[derive(PartialEq, Clone, Debug)]
4523    #[repr(C)]
4524    pub struct CapabilityStoreDictionaryRemoveResponse {}
4525
4526    impl ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveResponse {
4527        type Encoded = crate::wire::CapabilityStoreDictionaryRemoveResponse;
4528    }
4529
4530    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryRemoveResponse
4531    where
4532        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4533    {
4534        #[inline]
4535        fn encode(
4536            self,
4537            encoder_: &mut ___E,
4538            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4539            _: (),
4540        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4541            *out_ = ::core::mem::MaybeUninit::zeroed();
4542
4543            Ok(())
4544        }
4545    }
4546
4547    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryRemoveResponse
4548    where
4549        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4550    {
4551        #[inline]
4552        fn encode_ref(
4553            &self,
4554            encoder_: &mut ___E,
4555            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4556            _: (),
4557        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4558            ::fidl_next::munge! {
4559                let Self::Encoded {
4560
4561                        _empty,
4562
4563
4564                } = out_;
4565            }
4566
4567            Ok(())
4568        }
4569    }
4570
4571    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryRemoveResponse {
4572        type EncodedOption =
4573            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryRemoveResponse>;
4574    }
4575
4576    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryRemoveResponse
4577    where
4578        ___E: ::fidl_next::Encoder + ?Sized,
4579        CapabilityStoreDictionaryRemoveResponse: ::fidl_next::Encode<___E>,
4580    {
4581        #[inline]
4582        fn encode_option(
4583            this: ::core::option::Option<Self>,
4584            encoder: &mut ___E,
4585            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4586            _: (),
4587        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4588            if let Some(inner) = this {
4589                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4590                ::fidl_next::WireBox::encode_present(out);
4591            } else {
4592                ::fidl_next::WireBox::encode_absent(out);
4593            }
4594
4595            Ok(())
4596        }
4597    }
4598
4599    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryRemoveResponse
4600    where
4601        ___E: ::fidl_next::Encoder + ?Sized,
4602        CapabilityStoreDictionaryRemoveResponse: ::fidl_next::EncodeRef<___E>,
4603    {
4604        #[inline]
4605        fn encode_option_ref(
4606            this: ::core::option::Option<&Self>,
4607            encoder: &mut ___E,
4608            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4609            _: (),
4610        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4611            if let Some(inner) = this {
4612                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4613                ::fidl_next::WireBox::encode_present(out);
4614            } else {
4615                ::fidl_next::WireBox::encode_absent(out);
4616            }
4617
4618            Ok(())
4619        }
4620    }
4621
4622    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4623        for CapabilityStoreDictionaryRemoveResponse
4624    {
4625        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4626            crate::wire::CapabilityStoreDictionaryRemoveResponse,
4627            Self,
4628        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4629
4630        #[inline]
4631        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4632            Self {}
4633        }
4634    }
4635
4636    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryRemoveResponse>
4637        for CapabilityStoreDictionaryRemoveResponse
4638    {
4639        #[inline]
4640        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryRemoveResponse) -> Self {
4641            Self {}
4642        }
4643    }
4644
4645    #[derive(PartialEq, Clone, Debug)]
4646    #[repr(C)]
4647    pub struct CapabilityStoreDictionaryCopyRequest {
4648        pub id: u64,
4649
4650        pub dest_id: u64,
4651    }
4652
4653    impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest {
4654        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4655            Self,
4656            crate::wire::CapabilityStoreDictionaryCopyRequest,
4657        > = unsafe {
4658            ::fidl_next::CopyOptimization::enable_if(
4659                true && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
4660                    && <u64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
4661            )
4662        };
4663
4664        type Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest;
4665    }
4666
4667    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest
4668    where
4669        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4670    {
4671        #[inline]
4672        fn encode(
4673            self,
4674            encoder_: &mut ___E,
4675            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4676            _: (),
4677        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4678            ::fidl_next::munge! {
4679                let Self::Encoded {
4680                    id,
4681                    dest_id,
4682
4683                } = out_;
4684            }
4685
4686            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4687
4688            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4689
4690            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
4691
4692            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4693
4694            Ok(())
4695        }
4696    }
4697
4698    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyRequest
4699    where
4700        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4701    {
4702        #[inline]
4703        fn encode_ref(
4704            &self,
4705            encoder_: &mut ___E,
4706            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4707            _: (),
4708        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4709            ::fidl_next::munge! {
4710                let Self::Encoded {
4711
4712                    id,
4713                    dest_id,
4714
4715                } = out_;
4716            }
4717
4718            ::fidl_next::EncodeRef::encode_ref(&self.id, encoder_, id, ())?;
4719
4720            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4721
4722            ::fidl_next::EncodeRef::encode_ref(&self.dest_id, encoder_, dest_id, ())?;
4723
4724            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dest_id.as_mut_ptr()) };
4725
4726            Ok(())
4727        }
4728    }
4729
4730    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyRequest {
4731        type EncodedOption =
4732            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCopyRequest>;
4733    }
4734
4735    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyRequest
4736    where
4737        ___E: ::fidl_next::Encoder + ?Sized,
4738        CapabilityStoreDictionaryCopyRequest: ::fidl_next::Encode<___E>,
4739    {
4740        #[inline]
4741        fn encode_option(
4742            this: ::core::option::Option<Self>,
4743            encoder: &mut ___E,
4744            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4745            _: (),
4746        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4747            if let Some(inner) = this {
4748                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4749                ::fidl_next::WireBox::encode_present(out);
4750            } else {
4751                ::fidl_next::WireBox::encode_absent(out);
4752            }
4753
4754            Ok(())
4755        }
4756    }
4757
4758    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyRequest
4759    where
4760        ___E: ::fidl_next::Encoder + ?Sized,
4761        CapabilityStoreDictionaryCopyRequest: ::fidl_next::EncodeRef<___E>,
4762    {
4763        #[inline]
4764        fn encode_option_ref(
4765            this: ::core::option::Option<&Self>,
4766            encoder: &mut ___E,
4767            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4768            _: (),
4769        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4770            if let Some(inner) = this {
4771                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4772                ::fidl_next::WireBox::encode_present(out);
4773            } else {
4774                ::fidl_next::WireBox::encode_absent(out);
4775            }
4776
4777            Ok(())
4778        }
4779    }
4780
4781    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyRequest>
4782        for CapabilityStoreDictionaryCopyRequest
4783    {
4784        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4785            crate::wire::CapabilityStoreDictionaryCopyRequest,
4786            Self,
4787        > = unsafe {
4788            ::fidl_next::CopyOptimization::enable_if(
4789                true && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4790                    .is_enabled()
4791                    && <u64 as ::fidl_next::FromWire<::fidl_next::WireU64>>::COPY_OPTIMIZATION
4792                        .is_enabled(),
4793            )
4794        };
4795
4796        #[inline]
4797        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4798            Self {
4799                id: ::fidl_next::FromWire::from_wire(wire.id),
4800
4801                dest_id: ::fidl_next::FromWire::from_wire(wire.dest_id),
4802            }
4803        }
4804    }
4805
4806    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyRequest>
4807        for CapabilityStoreDictionaryCopyRequest
4808    {
4809        #[inline]
4810        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyRequest) -> Self {
4811            Self {
4812                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
4813
4814                dest_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.dest_id),
4815            }
4816        }
4817    }
4818
4819    #[derive(PartialEq, Clone, Debug)]
4820    #[repr(C)]
4821    pub struct CapabilityStoreDictionaryCopyResponse {}
4822
4823    impl ::fidl_next::Encodable for CapabilityStoreDictionaryCopyResponse {
4824        type Encoded = crate::wire::CapabilityStoreDictionaryCopyResponse;
4825    }
4826
4827    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyResponse
4828    where
4829        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4830    {
4831        #[inline]
4832        fn encode(
4833            self,
4834            encoder_: &mut ___E,
4835            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4836            _: (),
4837        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4838            *out_ = ::core::mem::MaybeUninit::zeroed();
4839
4840            Ok(())
4841        }
4842    }
4843
4844    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryCopyResponse
4845    where
4846        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4847    {
4848        #[inline]
4849        fn encode_ref(
4850            &self,
4851            encoder_: &mut ___E,
4852            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4853            _: (),
4854        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4855            ::fidl_next::munge! {
4856                let Self::Encoded {
4857
4858                        _empty,
4859
4860
4861                } = out_;
4862            }
4863
4864            Ok(())
4865        }
4866    }
4867
4868    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryCopyResponse {
4869        type EncodedOption =
4870            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryCopyResponse>;
4871    }
4872
4873    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryCopyResponse
4874    where
4875        ___E: ::fidl_next::Encoder + ?Sized,
4876        CapabilityStoreDictionaryCopyResponse: ::fidl_next::Encode<___E>,
4877    {
4878        #[inline]
4879        fn encode_option(
4880            this: ::core::option::Option<Self>,
4881            encoder: &mut ___E,
4882            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4883            _: (),
4884        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4885            if let Some(inner) = this {
4886                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4887                ::fidl_next::WireBox::encode_present(out);
4888            } else {
4889                ::fidl_next::WireBox::encode_absent(out);
4890            }
4891
4892            Ok(())
4893        }
4894    }
4895
4896    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryCopyResponse
4897    where
4898        ___E: ::fidl_next::Encoder + ?Sized,
4899        CapabilityStoreDictionaryCopyResponse: ::fidl_next::EncodeRef<___E>,
4900    {
4901        #[inline]
4902        fn encode_option_ref(
4903            this: ::core::option::Option<&Self>,
4904            encoder: &mut ___E,
4905            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
4906            _: (),
4907        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4908            if let Some(inner) = this {
4909                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
4910                ::fidl_next::WireBox::encode_present(out);
4911            } else {
4912                ::fidl_next::WireBox::encode_absent(out);
4913            }
4914
4915            Ok(())
4916        }
4917    }
4918
4919    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryCopyResponse>
4920        for CapabilityStoreDictionaryCopyResponse
4921    {
4922        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4923            crate::wire::CapabilityStoreDictionaryCopyResponse,
4924            Self,
4925        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
4926
4927        #[inline]
4928        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4929            Self {}
4930        }
4931    }
4932
4933    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryCopyResponse>
4934        for CapabilityStoreDictionaryCopyResponse
4935    {
4936        #[inline]
4937        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryCopyResponse) -> Self {
4938            Self {}
4939        }
4940    }
4941
4942    #[derive(PartialEq, Debug)]
4943    pub struct CapabilityStoreDictionaryKeysRequest {
4944        pub id: u64,
4945
4946        pub iterator: ::fidl_next::ServerEnd<
4947            crate::DictionaryKeysIterator,
4948            ::fidl_next::fuchsia::zx::Channel,
4949        >,
4950    }
4951
4952    impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest {
4953        type Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest;
4954    }
4955
4956    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest
4957    where
4958        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4959        ___E: ::fidl_next::fuchsia::HandleEncoder,
4960    {
4961        #[inline]
4962        fn encode(
4963            self,
4964            encoder_: &mut ___E,
4965            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
4966            _: (),
4967        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4968            ::fidl_next::munge! {
4969                let Self::Encoded {
4970                    id,
4971                    iterator,
4972
4973                } = out_;
4974            }
4975
4976            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
4977
4978            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
4979
4980            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
4981
4982            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
4983
4984            Ok(())
4985        }
4986    }
4987
4988    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysRequest {
4989        type EncodedOption =
4990            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysRequest>;
4991    }
4992
4993    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysRequest
4994    where
4995        ___E: ::fidl_next::Encoder + ?Sized,
4996        CapabilityStoreDictionaryKeysRequest: ::fidl_next::Encode<___E>,
4997    {
4998        #[inline]
4999        fn encode_option(
5000            this: ::core::option::Option<Self>,
5001            encoder: &mut ___E,
5002            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5003            _: (),
5004        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5005            if let Some(inner) = this {
5006                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5007                ::fidl_next::WireBox::encode_present(out);
5008            } else {
5009                ::fidl_next::WireBox::encode_absent(out);
5010            }
5011
5012            Ok(())
5013        }
5014    }
5015
5016    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysRequest>
5017        for CapabilityStoreDictionaryKeysRequest
5018    {
5019        #[inline]
5020        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysRequest) -> Self {
5021            Self {
5022                id: ::fidl_next::FromWire::from_wire(wire.id),
5023
5024                iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5025            }
5026        }
5027    }
5028
5029    #[derive(PartialEq, Clone, Debug)]
5030    #[repr(C)]
5031    pub struct CapabilityStoreDictionaryKeysResponse {}
5032
5033    impl ::fidl_next::Encodable for CapabilityStoreDictionaryKeysResponse {
5034        type Encoded = crate::wire::CapabilityStoreDictionaryKeysResponse;
5035    }
5036
5037    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysResponse
5038    where
5039        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5040    {
5041        #[inline]
5042        fn encode(
5043            self,
5044            encoder_: &mut ___E,
5045            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5046            _: (),
5047        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5048            *out_ = ::core::mem::MaybeUninit::zeroed();
5049
5050            Ok(())
5051        }
5052    }
5053
5054    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryKeysResponse
5055    where
5056        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5057    {
5058        #[inline]
5059        fn encode_ref(
5060            &self,
5061            encoder_: &mut ___E,
5062            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5063            _: (),
5064        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5065            ::fidl_next::munge! {
5066                let Self::Encoded {
5067
5068                        _empty,
5069
5070
5071                } = out_;
5072            }
5073
5074            Ok(())
5075        }
5076    }
5077
5078    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryKeysResponse {
5079        type EncodedOption =
5080            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryKeysResponse>;
5081    }
5082
5083    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryKeysResponse
5084    where
5085        ___E: ::fidl_next::Encoder + ?Sized,
5086        CapabilityStoreDictionaryKeysResponse: ::fidl_next::Encode<___E>,
5087    {
5088        #[inline]
5089        fn encode_option(
5090            this: ::core::option::Option<Self>,
5091            encoder: &mut ___E,
5092            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5093            _: (),
5094        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5095            if let Some(inner) = this {
5096                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5097                ::fidl_next::WireBox::encode_present(out);
5098            } else {
5099                ::fidl_next::WireBox::encode_absent(out);
5100            }
5101
5102            Ok(())
5103        }
5104    }
5105
5106    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryKeysResponse
5107    where
5108        ___E: ::fidl_next::Encoder + ?Sized,
5109        CapabilityStoreDictionaryKeysResponse: ::fidl_next::EncodeRef<___E>,
5110    {
5111        #[inline]
5112        fn encode_option_ref(
5113            this: ::core::option::Option<&Self>,
5114            encoder: &mut ___E,
5115            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5116            _: (),
5117        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5118            if let Some(inner) = this {
5119                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5120                ::fidl_next::WireBox::encode_present(out);
5121            } else {
5122                ::fidl_next::WireBox::encode_absent(out);
5123            }
5124
5125            Ok(())
5126        }
5127    }
5128
5129    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryKeysResponse>
5130        for CapabilityStoreDictionaryKeysResponse
5131    {
5132        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5133            crate::wire::CapabilityStoreDictionaryKeysResponse,
5134            Self,
5135        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5136
5137        #[inline]
5138        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
5139            Self {}
5140        }
5141    }
5142
5143    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryKeysResponse>
5144        for CapabilityStoreDictionaryKeysResponse
5145    {
5146        #[inline]
5147        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryKeysResponse) -> Self {
5148            Self {}
5149        }
5150    }
5151
5152    #[derive(PartialEq, Debug)]
5153    pub struct CapabilityStoreDictionaryEnumerateRequest {
5154        pub id: u64,
5155
5156        pub iterator: ::fidl_next::ServerEnd<
5157            crate::DictionaryEnumerateIterator,
5158            ::fidl_next::fuchsia::zx::Channel,
5159        >,
5160    }
5161
5162    impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest {
5163        type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
5164    }
5165
5166    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateRequest
5167    where
5168        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5169        ___E: ::fidl_next::fuchsia::HandleEncoder,
5170    {
5171        #[inline]
5172        fn encode(
5173            self,
5174            encoder_: &mut ___E,
5175            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5176            _: (),
5177        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5178            ::fidl_next::munge! {
5179                let Self::Encoded {
5180                    id,
5181                    iterator,
5182
5183                } = out_;
5184            }
5185
5186            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5187
5188            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5189
5190            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5191
5192            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
5193
5194            Ok(())
5195        }
5196    }
5197
5198    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateRequest {
5199        type EncodedOption =
5200            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateRequest>;
5201    }
5202
5203    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateRequest
5204    where
5205        ___E: ::fidl_next::Encoder + ?Sized,
5206        CapabilityStoreDictionaryEnumerateRequest: ::fidl_next::Encode<___E>,
5207    {
5208        #[inline]
5209        fn encode_option(
5210            this: ::core::option::Option<Self>,
5211            encoder: &mut ___E,
5212            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5213            _: (),
5214        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5215            if let Some(inner) = this {
5216                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5217                ::fidl_next::WireBox::encode_present(out);
5218            } else {
5219                ::fidl_next::WireBox::encode_absent(out);
5220            }
5221
5222            Ok(())
5223        }
5224    }
5225
5226    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateRequest>
5227        for CapabilityStoreDictionaryEnumerateRequest
5228    {
5229        #[inline]
5230        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateRequest) -> Self {
5231            Self {
5232                id: ::fidl_next::FromWire::from_wire(wire.id),
5233
5234                iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5235            }
5236        }
5237    }
5238
5239    #[derive(PartialEq, Clone, Debug)]
5240    #[repr(C)]
5241    pub struct CapabilityStoreDictionaryEnumerateResponse {}
5242
5243    impl ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateResponse {
5244        type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateResponse;
5245    }
5246
5247    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryEnumerateResponse
5248    where
5249        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5250    {
5251        #[inline]
5252        fn encode(
5253            self,
5254            encoder_: &mut ___E,
5255            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5256            _: (),
5257        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5258            *out_ = ::core::mem::MaybeUninit::zeroed();
5259
5260            Ok(())
5261        }
5262    }
5263
5264    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryEnumerateResponse
5265    where
5266        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5267    {
5268        #[inline]
5269        fn encode_ref(
5270            &self,
5271            encoder_: &mut ___E,
5272            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5273            _: (),
5274        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5275            ::fidl_next::munge! {
5276                let Self::Encoded {
5277
5278                        _empty,
5279
5280
5281                } = out_;
5282            }
5283
5284            Ok(())
5285        }
5286    }
5287
5288    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryEnumerateResponse {
5289        type EncodedOption =
5290            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryEnumerateResponse>;
5291    }
5292
5293    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryEnumerateResponse
5294    where
5295        ___E: ::fidl_next::Encoder + ?Sized,
5296        CapabilityStoreDictionaryEnumerateResponse: ::fidl_next::Encode<___E>,
5297    {
5298        #[inline]
5299        fn encode_option(
5300            this: ::core::option::Option<Self>,
5301            encoder: &mut ___E,
5302            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5303            _: (),
5304        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5305            if let Some(inner) = this {
5306                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5307                ::fidl_next::WireBox::encode_present(out);
5308            } else {
5309                ::fidl_next::WireBox::encode_absent(out);
5310            }
5311
5312            Ok(())
5313        }
5314    }
5315
5316    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryEnumerateResponse
5317    where
5318        ___E: ::fidl_next::Encoder + ?Sized,
5319        CapabilityStoreDictionaryEnumerateResponse: ::fidl_next::EncodeRef<___E>,
5320    {
5321        #[inline]
5322        fn encode_option_ref(
5323            this: ::core::option::Option<&Self>,
5324            encoder: &mut ___E,
5325            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5326            _: (),
5327        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5328            if let Some(inner) = this {
5329                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5330                ::fidl_next::WireBox::encode_present(out);
5331            } else {
5332                ::fidl_next::WireBox::encode_absent(out);
5333            }
5334
5335            Ok(())
5336        }
5337    }
5338
5339    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
5340        for CapabilityStoreDictionaryEnumerateResponse
5341    {
5342        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5343            crate::wire::CapabilityStoreDictionaryEnumerateResponse,
5344            Self,
5345        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5346
5347        #[inline]
5348        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
5349            Self {}
5350        }
5351    }
5352
5353    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryEnumerateResponse>
5354        for CapabilityStoreDictionaryEnumerateResponse
5355    {
5356        #[inline]
5357        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryEnumerateResponse) -> Self {
5358            Self {}
5359        }
5360    }
5361
5362    #[derive(PartialEq, Debug)]
5363    pub struct CapabilityStoreDictionaryDrainRequest {
5364        pub id: u64,
5365
5366        pub iterator: ::core::option::Option<
5367            ::fidl_next::ServerEnd<
5368                crate::DictionaryDrainIterator,
5369                ::fidl_next::fuchsia::zx::Channel,
5370            >,
5371        >,
5372    }
5373
5374    impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest {
5375        type Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest;
5376    }
5377
5378    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainRequest
5379    where
5380        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5381        ___E: ::fidl_next::fuchsia::HandleEncoder,
5382    {
5383        #[inline]
5384        fn encode(
5385            self,
5386            encoder_: &mut ___E,
5387            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5388            _: (),
5389        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5390            ::fidl_next::munge! {
5391                let Self::Encoded {
5392                    id,
5393                    iterator,
5394
5395                } = out_;
5396            }
5397
5398            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5399
5400            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5401
5402            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5403
5404            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
5405
5406            Ok(())
5407        }
5408    }
5409
5410    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainRequest {
5411        type EncodedOption =
5412            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainRequest>;
5413    }
5414
5415    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainRequest
5416    where
5417        ___E: ::fidl_next::Encoder + ?Sized,
5418        CapabilityStoreDictionaryDrainRequest: ::fidl_next::Encode<___E>,
5419    {
5420        #[inline]
5421        fn encode_option(
5422            this: ::core::option::Option<Self>,
5423            encoder: &mut ___E,
5424            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5425            _: (),
5426        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5427            if let Some(inner) = this {
5428                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5429                ::fidl_next::WireBox::encode_present(out);
5430            } else {
5431                ::fidl_next::WireBox::encode_absent(out);
5432            }
5433
5434            Ok(())
5435        }
5436    }
5437
5438    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainRequest>
5439        for CapabilityStoreDictionaryDrainRequest
5440    {
5441        #[inline]
5442        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainRequest) -> Self {
5443            Self {
5444                id: ::fidl_next::FromWire::from_wire(wire.id),
5445
5446                iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
5447            }
5448        }
5449    }
5450
5451    #[derive(PartialEq, Clone, Debug)]
5452    #[repr(C)]
5453    pub struct CapabilityStoreDictionaryDrainResponse {}
5454
5455    impl ::fidl_next::Encodable for CapabilityStoreDictionaryDrainResponse {
5456        type Encoded = crate::wire::CapabilityStoreDictionaryDrainResponse;
5457    }
5458
5459    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryDrainResponse
5460    where
5461        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5462    {
5463        #[inline]
5464        fn encode(
5465            self,
5466            encoder_: &mut ___E,
5467            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5468            _: (),
5469        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5470            *out_ = ::core::mem::MaybeUninit::zeroed();
5471
5472            Ok(())
5473        }
5474    }
5475
5476    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CapabilityStoreDictionaryDrainResponse
5477    where
5478        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5479    {
5480        #[inline]
5481        fn encode_ref(
5482            &self,
5483            encoder_: &mut ___E,
5484            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5485            _: (),
5486        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5487            ::fidl_next::munge! {
5488                let Self::Encoded {
5489
5490                        _empty,
5491
5492
5493                } = out_;
5494            }
5495
5496            Ok(())
5497        }
5498    }
5499
5500    impl ::fidl_next::EncodableOption for CapabilityStoreDictionaryDrainResponse {
5501        type EncodedOption =
5502            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDictionaryDrainResponse>;
5503    }
5504
5505    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDictionaryDrainResponse
5506    where
5507        ___E: ::fidl_next::Encoder + ?Sized,
5508        CapabilityStoreDictionaryDrainResponse: ::fidl_next::Encode<___E>,
5509    {
5510        #[inline]
5511        fn encode_option(
5512            this: ::core::option::Option<Self>,
5513            encoder: &mut ___E,
5514            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5515            _: (),
5516        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5517            if let Some(inner) = this {
5518                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5519                ::fidl_next::WireBox::encode_present(out);
5520            } else {
5521                ::fidl_next::WireBox::encode_absent(out);
5522            }
5523
5524            Ok(())
5525        }
5526    }
5527
5528    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CapabilityStoreDictionaryDrainResponse
5529    where
5530        ___E: ::fidl_next::Encoder + ?Sized,
5531        CapabilityStoreDictionaryDrainResponse: ::fidl_next::EncodeRef<___E>,
5532    {
5533        #[inline]
5534        fn encode_option_ref(
5535            this: ::core::option::Option<&Self>,
5536            encoder: &mut ___E,
5537            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5538            _: (),
5539        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5540            if let Some(inner) = this {
5541                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5542                ::fidl_next::WireBox::encode_present(out);
5543            } else {
5544                ::fidl_next::WireBox::encode_absent(out);
5545            }
5546
5547            Ok(())
5548        }
5549    }
5550
5551    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDictionaryDrainResponse>
5552        for CapabilityStoreDictionaryDrainResponse
5553    {
5554        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
5555            crate::wire::CapabilityStoreDictionaryDrainResponse,
5556            Self,
5557        > = unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
5558
5559        #[inline]
5560        fn from_wire(wire: crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
5561            Self {}
5562        }
5563    }
5564
5565    impl ::fidl_next::FromWireRef<crate::wire::CapabilityStoreDictionaryDrainResponse>
5566        for CapabilityStoreDictionaryDrainResponse
5567    {
5568        #[inline]
5569        fn from_wire_ref(wire: &crate::wire::CapabilityStoreDictionaryDrainResponse) -> Self {
5570            Self {}
5571        }
5572    }
5573
5574    #[derive(PartialEq, Debug)]
5575    pub struct CapabilityStoreExportResponse {
5576        pub capability: crate::natural::Capability,
5577    }
5578
5579    impl ::fidl_next::Encodable for CapabilityStoreExportResponse {
5580        type Encoded = crate::wire::CapabilityStoreExportResponse<'static>;
5581    }
5582
5583    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse
5584    where
5585        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5586        ___E: ::fidl_next::Encoder,
5587        ___E: ::fidl_next::fuchsia::HandleEncoder,
5588    {
5589        #[inline]
5590        fn encode(
5591            self,
5592            encoder_: &mut ___E,
5593            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5594            _: (),
5595        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5596            ::fidl_next::munge! {
5597                let Self::Encoded {
5598                    capability,
5599
5600                } = out_;
5601            }
5602
5603            ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
5604
5605            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
5606
5607            Ok(())
5608        }
5609    }
5610
5611    impl ::fidl_next::EncodableOption for CapabilityStoreExportResponse {
5612        type EncodedOption =
5613            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreExportResponse<'static>>;
5614    }
5615
5616    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreExportResponse
5617    where
5618        ___E: ::fidl_next::Encoder + ?Sized,
5619        CapabilityStoreExportResponse: ::fidl_next::Encode<___E>,
5620    {
5621        #[inline]
5622        fn encode_option(
5623            this: ::core::option::Option<Self>,
5624            encoder: &mut ___E,
5625            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5626            _: (),
5627        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5628            if let Some(inner) = this {
5629                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5630                ::fidl_next::WireBox::encode_present(out);
5631            } else {
5632                ::fidl_next::WireBox::encode_absent(out);
5633            }
5634
5635            Ok(())
5636        }
5637    }
5638
5639    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreExportResponse<'de>>
5640        for CapabilityStoreExportResponse
5641    {
5642        #[inline]
5643        fn from_wire(wire: crate::wire::CapabilityStoreExportResponse<'de>) -> Self {
5644            Self { capability: ::fidl_next::FromWire::from_wire(wire.capability) }
5645        }
5646    }
5647
5648    #[derive(PartialEq, Debug)]
5649    pub struct CapabilityStoreImportRequest {
5650        pub id: u64,
5651
5652        pub capability: crate::natural::Capability,
5653    }
5654
5655    impl ::fidl_next::Encodable for CapabilityStoreImportRequest {
5656        type Encoded = crate::wire::CapabilityStoreImportRequest<'static>;
5657    }
5658
5659    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest
5660    where
5661        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5662        ___E: ::fidl_next::Encoder,
5663        ___E: ::fidl_next::fuchsia::HandleEncoder,
5664    {
5665        #[inline]
5666        fn encode(
5667            self,
5668            encoder_: &mut ___E,
5669            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5670            _: (),
5671        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5672            ::fidl_next::munge! {
5673                let Self::Encoded {
5674                    id,
5675                    capability,
5676
5677                } = out_;
5678            }
5679
5680            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5681
5682            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5683
5684            ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
5685
5686            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
5687
5688            Ok(())
5689        }
5690    }
5691
5692    impl ::fidl_next::EncodableOption for CapabilityStoreImportRequest {
5693        type EncodedOption =
5694            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreImportRequest<'static>>;
5695    }
5696
5697    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreImportRequest
5698    where
5699        ___E: ::fidl_next::Encoder + ?Sized,
5700        CapabilityStoreImportRequest: ::fidl_next::Encode<___E>,
5701    {
5702        #[inline]
5703        fn encode_option(
5704            this: ::core::option::Option<Self>,
5705            encoder: &mut ___E,
5706            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5707            _: (),
5708        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5709            if let Some(inner) = this {
5710                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5711                ::fidl_next::WireBox::encode_present(out);
5712            } else {
5713                ::fidl_next::WireBox::encode_absent(out);
5714            }
5715
5716            Ok(())
5717        }
5718    }
5719
5720    impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityStoreImportRequest<'de>>
5721        for CapabilityStoreImportRequest
5722    {
5723        #[inline]
5724        fn from_wire(wire: crate::wire::CapabilityStoreImportRequest<'de>) -> Self {
5725            Self {
5726                id: ::fidl_next::FromWire::from_wire(wire.id),
5727
5728                capability: ::fidl_next::FromWire::from_wire(wire.capability),
5729            }
5730        }
5731    }
5732
5733    #[derive(PartialEq, Debug)]
5734    pub struct CapabilityStoreDirConnectorCreateRequest {
5735        pub id: u64,
5736
5737        pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::zx::Channel>,
5738    }
5739
5740    impl ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest {
5741        type Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest;
5742    }
5743
5744    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorCreateRequest
5745    where
5746        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5747        ___E: ::fidl_next::fuchsia::HandleEncoder,
5748    {
5749        #[inline]
5750        fn encode(
5751            self,
5752            encoder_: &mut ___E,
5753            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5754            _: (),
5755        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5756            ::fidl_next::munge! {
5757                let Self::Encoded {
5758                    id,
5759                    receiver,
5760
5761                } = out_;
5762            }
5763
5764            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5765
5766            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5767
5768            ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
5769
5770            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(receiver.as_mut_ptr()) };
5771
5772            Ok(())
5773        }
5774    }
5775
5776    impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorCreateRequest {
5777        type EncodedOption =
5778            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorCreateRequest>;
5779    }
5780
5781    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorCreateRequest
5782    where
5783        ___E: ::fidl_next::Encoder + ?Sized,
5784        CapabilityStoreDirConnectorCreateRequest: ::fidl_next::Encode<___E>,
5785    {
5786        #[inline]
5787        fn encode_option(
5788            this: ::core::option::Option<Self>,
5789            encoder: &mut ___E,
5790            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5791            _: (),
5792        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5793            if let Some(inner) = this {
5794                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5795                ::fidl_next::WireBox::encode_present(out);
5796            } else {
5797                ::fidl_next::WireBox::encode_absent(out);
5798            }
5799
5800            Ok(())
5801        }
5802    }
5803
5804    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorCreateRequest>
5805        for CapabilityStoreDirConnectorCreateRequest
5806    {
5807        #[inline]
5808        fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorCreateRequest) -> Self {
5809            Self {
5810                id: ::fidl_next::FromWire::from_wire(wire.id),
5811
5812                receiver: ::fidl_next::FromWire::from_wire(wire.receiver),
5813            }
5814        }
5815    }
5816
5817    #[derive(PartialEq, Debug)]
5818    pub struct CapabilityStoreDirConnectorOpenRequest {
5819        pub id: u64,
5820
5821        pub server_end: ::fidl_next::ServerEnd<
5822            ::fidl_next_fuchsia_io::Directory,
5823            ::fidl_next::fuchsia::zx::Channel,
5824        >,
5825    }
5826
5827    impl ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest {
5828        type Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest;
5829    }
5830
5831    unsafe impl<___E> ::fidl_next::Encode<___E> for CapabilityStoreDirConnectorOpenRequest
5832    where
5833        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5834        ___E: ::fidl_next::fuchsia::HandleEncoder,
5835    {
5836        #[inline]
5837        fn encode(
5838            self,
5839            encoder_: &mut ___E,
5840            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5841            _: (),
5842        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5843            ::fidl_next::munge! {
5844                let Self::Encoded {
5845                    id,
5846                    server_end,
5847
5848                } = out_;
5849            }
5850
5851            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
5852
5853            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
5854
5855            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
5856
5857            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server_end.as_mut_ptr()) };
5858
5859            Ok(())
5860        }
5861    }
5862
5863    impl ::fidl_next::EncodableOption for CapabilityStoreDirConnectorOpenRequest {
5864        type EncodedOption =
5865            ::fidl_next::WireBox<'static, crate::wire::CapabilityStoreDirConnectorOpenRequest>;
5866    }
5867
5868    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for CapabilityStoreDirConnectorOpenRequest
5869    where
5870        ___E: ::fidl_next::Encoder + ?Sized,
5871        CapabilityStoreDirConnectorOpenRequest: ::fidl_next::Encode<___E>,
5872    {
5873        #[inline]
5874        fn encode_option(
5875            this: ::core::option::Option<Self>,
5876            encoder: &mut ___E,
5877            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5878            _: (),
5879        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5880            if let Some(inner) = this {
5881                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5882                ::fidl_next::WireBox::encode_present(out);
5883            } else {
5884                ::fidl_next::WireBox::encode_absent(out);
5885            }
5886
5887            Ok(())
5888        }
5889    }
5890
5891    impl ::fidl_next::FromWire<crate::wire::CapabilityStoreDirConnectorOpenRequest>
5892        for CapabilityStoreDirConnectorOpenRequest
5893    {
5894        #[inline]
5895        fn from_wire(wire: crate::wire::CapabilityStoreDirConnectorOpenRequest) -> Self {
5896            Self {
5897                id: ::fidl_next::FromWire::from_wire(wire.id),
5898
5899                server_end: ::fidl_next::FromWire::from_wire(wire.server_end),
5900            }
5901        }
5902    }
5903
5904    #[doc = " Represents an instance in the component tree, either a component\n instance or component manager\'s instance.\n"]
5905    #[derive(PartialEq, Debug)]
5906    #[repr(C)]
5907    pub struct InstanceToken {
5908        pub token: ::fidl_next::fuchsia::zx::EventPair,
5909    }
5910
5911    impl ::fidl_next::Encodable for InstanceToken {
5912        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::InstanceToken> = unsafe {
5913            ::fidl_next::CopyOptimization::enable_if(
5914            true
5915
5916                && <
5917                    ::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encodable
5918                >::COPY_OPTIMIZATION.is_enabled()
5919
5920        )
5921        };
5922
5923        type Encoded = crate::wire::InstanceToken;
5924    }
5925
5926    unsafe impl<___E> ::fidl_next::Encode<___E> for InstanceToken
5927    where
5928        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5929        ___E: ::fidl_next::fuchsia::HandleEncoder,
5930    {
5931        #[inline]
5932        fn encode(
5933            self,
5934            encoder_: &mut ___E,
5935            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
5936            _: (),
5937        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5938            ::fidl_next::munge! {
5939                let Self::Encoded {
5940                    token,
5941
5942                } = out_;
5943            }
5944
5945            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5946
5947            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
5948
5949            Ok(())
5950        }
5951    }
5952
5953    impl ::fidl_next::EncodableOption for InstanceToken {
5954        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::InstanceToken>;
5955    }
5956
5957    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for InstanceToken
5958    where
5959        ___E: ::fidl_next::Encoder + ?Sized,
5960        InstanceToken: ::fidl_next::Encode<___E>,
5961    {
5962        #[inline]
5963        fn encode_option(
5964            this: ::core::option::Option<Self>,
5965            encoder: &mut ___E,
5966            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
5967            _: (),
5968        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5969            if let Some(inner) = this {
5970                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
5971                ::fidl_next::WireBox::encode_present(out);
5972            } else {
5973                ::fidl_next::WireBox::encode_absent(out);
5974            }
5975
5976            Ok(())
5977        }
5978    }
5979
5980    impl ::fidl_next::FromWire<crate::wire::InstanceToken> for InstanceToken {
5981        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::InstanceToken, Self> = unsafe {
5982            ::fidl_next::CopyOptimization::enable_if(
5983                true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
5984                    ::fidl_next::fuchsia::WireEventPair,
5985                >>::COPY_OPTIMIZATION
5986                    .is_enabled(),
5987            )
5988        };
5989
5990        #[inline]
5991        fn from_wire(wire: crate::wire::InstanceToken) -> Self {
5992            Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
5993        }
5994    }
5995
5996    #[doc = " A request for a route.\n"]
5997    #[derive(PartialEq, Debug, Default)]
5998    pub struct RouteRequest {
5999        pub requesting: ::core::option::Option<crate::natural::InstanceToken>,
6000
6001        pub metadata: ::core::option::Option<crate::natural::DictionaryRef>,
6002    }
6003
6004    impl RouteRequest {
6005        fn __max_ordinal(&self) -> usize {
6006            if self.metadata.is_some() {
6007                return 2;
6008            }
6009
6010            if self.requesting.is_some() {
6011                return 1;
6012            }
6013
6014            0
6015        }
6016    }
6017
6018    impl ::fidl_next::Encodable for RouteRequest {
6019        type Encoded = crate::wire::RouteRequest<'static>;
6020    }
6021
6022    unsafe impl<___E> ::fidl_next::Encode<___E> for RouteRequest
6023    where
6024        ___E: ::fidl_next::Encoder + ?Sized,
6025        ___E: ::fidl_next::fuchsia::HandleEncoder,
6026    {
6027        #[inline]
6028        fn encode(
6029            mut self,
6030            encoder: &mut ___E,
6031            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6032            _: (),
6033        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6034            ::fidl_next::munge!(let crate::wire::RouteRequest { table } = out);
6035
6036            let max_ord = self.__max_ordinal();
6037
6038            let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
6039            ::fidl_next::Wire::zero_padding(&mut out);
6040
6041            let mut preallocated =
6042                ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);
6043
6044            for i in 1..=max_ord {
6045                match i {
6046                    2 => {
6047                        if let Some(value) = self.metadata.take() {
6048                            ::fidl_next::WireEnvelope::encode_value(
6049                                value,
6050                                preallocated.encoder,
6051                                &mut out,
6052                                (),
6053                            )?;
6054                        } else {
6055                            ::fidl_next::WireEnvelope::encode_zero(&mut out)
6056                        }
6057                    }
6058
6059                    1 => {
6060                        if let Some(value) = self.requesting.take() {
6061                            ::fidl_next::WireEnvelope::encode_value(
6062                                value,
6063                                preallocated.encoder,
6064                                &mut out,
6065                                (),
6066                            )?;
6067                        } else {
6068                            ::fidl_next::WireEnvelope::encode_zero(&mut out)
6069                        }
6070                    }
6071
6072                    _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
6073                }
6074                unsafe {
6075                    preallocated.write_next(out.assume_init_ref());
6076                }
6077            }
6078
6079            ::fidl_next::WireTable::encode_len(table, max_ord);
6080
6081            Ok(())
6082        }
6083    }
6084
6085    impl<'de> ::fidl_next::FromWire<crate::wire::RouteRequest<'de>> for RouteRequest {
6086        #[inline]
6087        fn from_wire(wire_: crate::wire::RouteRequest<'de>) -> Self {
6088            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6089
6090            let requesting = wire_.table.get(1);
6091
6092            let metadata = wire_.table.get(2);
6093
6094            Self {
6095                requesting: requesting.map(|envelope| {
6096                    ::fidl_next::FromWire::from_wire(unsafe {
6097                        envelope.read_unchecked::<crate::wire::InstanceToken>()
6098                    })
6099                }),
6100
6101                metadata: metadata.map(|envelope| {
6102                    ::fidl_next::FromWire::from_wire(unsafe {
6103                        envelope.read_unchecked::<crate::wire::DictionaryRef>()
6104                    })
6105                }),
6106            }
6107        }
6108    }
6109
6110    #[derive(PartialEq, Debug)]
6111    pub enum ConnectorRouterRouteResponse {
6112        Connector(crate::natural::Connector),
6113
6114        Unavailable(crate::natural::Unit),
6115    }
6116
6117    impl ::fidl_next::Encodable for ConnectorRouterRouteResponse {
6118        type Encoded = crate::wire::ConnectorRouterRouteResponse;
6119    }
6120
6121    unsafe impl<___E> ::fidl_next::Encode<___E> for ConnectorRouterRouteResponse
6122    where
6123        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6124        ___E: ::fidl_next::fuchsia::HandleEncoder,
6125    {
6126        #[inline]
6127        fn encode(
6128            self,
6129            encoder: &mut ___E,
6130            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6131            _: (),
6132        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6133            ::fidl_next::munge!(let crate::wire::ConnectorRouterRouteResponse { raw, _phantom: _ } = out);
6134
6135            match self {
6136                Self::Connector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
6137                    ___E,
6138                    crate::natural::Connector,
6139                >(value, 1, encoder, raw, ())?,
6140
6141                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
6142                    ___E,
6143                    crate::natural::Unit,
6144                >(value, 2, encoder, raw, ())?,
6145            }
6146
6147            Ok(())
6148        }
6149    }
6150
6151    impl ::fidl_next::EncodableOption for ConnectorRouterRouteResponse {
6152        type EncodedOption = crate::wire_optional::ConnectorRouterRouteResponse;
6153    }
6154
6155    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ConnectorRouterRouteResponse
6156    where
6157        ___E: ?Sized,
6158        ConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
6159    {
6160        #[inline]
6161        fn encode_option(
6162            this: ::core::option::Option<Self>,
6163            encoder: &mut ___E,
6164            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6165            _: (),
6166        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6167            ::fidl_next::munge!(let crate::wire_optional::ConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
6168
6169            if let Some(inner) = this {
6170                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6171                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6172            } else {
6173                ::fidl_next::RawWireUnion::encode_absent(raw);
6174            }
6175
6176            Ok(())
6177        }
6178    }
6179
6180    impl ::fidl_next::FromWire<crate::wire::ConnectorRouterRouteResponse>
6181        for ConnectorRouterRouteResponse
6182    {
6183        #[inline]
6184        fn from_wire(wire: crate::wire::ConnectorRouterRouteResponse) -> Self {
6185            let wire = ::core::mem::ManuallyDrop::new(wire);
6186            match wire.raw.ordinal() {
6187                1 => Self::Connector(::fidl_next::FromWire::from_wire(unsafe {
6188                    wire.raw.get().read_unchecked::<crate::wire::Connector>()
6189                })),
6190
6191                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
6192                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
6193                })),
6194
6195                _ => unsafe { ::core::hint::unreachable_unchecked() },
6196            }
6197        }
6198    }
6199
6200    impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
6201        for ConnectorRouterRouteResponse
6202    {
6203        #[inline]
6204        fn from_wire_option(
6205            wire: crate::wire_optional::ConnectorRouterRouteResponse,
6206        ) -> ::core::option::Option<Self> {
6207            if let Some(inner) = wire.into_option() {
6208                Some(::fidl_next::FromWire::from_wire(inner))
6209            } else {
6210                None
6211            }
6212        }
6213    }
6214
6215    impl ::fidl_next::FromWireOption<crate::wire_optional::ConnectorRouterRouteResponse>
6216        for Box<ConnectorRouterRouteResponse>
6217    {
6218        #[inline]
6219        fn from_wire_option(
6220            wire: crate::wire_optional::ConnectorRouterRouteResponse,
6221        ) -> ::core::option::Option<Self> {
6222            <ConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
6223                crate::wire_optional::ConnectorRouterRouteResponse,
6224            >>::from_wire_option(wire)
6225            .map(Box::new)
6226        }
6227    }
6228
6229    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
6230    #[repr(u32)]
6231    pub enum RouterError {
6232        NotFound = 1,
6233        InvalidArgs = 2,
6234        NotSupported = 3,
6235        Internal = 4,
6236        UnknownOrdinal_(u32) = 5,
6237    }
6238
6239    impl ::fidl_next::Encodable for RouterError {
6240        type Encoded = crate::wire::RouterError;
6241    }
6242    impl ::std::convert::From<u32> for RouterError {
6243        fn from(value: u32) -> Self {
6244            match value {
6245                1 => Self::NotFound,
6246                2 => Self::InvalidArgs,
6247                3 => Self::NotSupported,
6248                4 => Self::Internal,
6249
6250                _ => Self::UnknownOrdinal_(value),
6251            }
6252        }
6253    }
6254
6255    unsafe impl<___E> ::fidl_next::Encode<___E> for RouterError
6256    where
6257        ___E: ?Sized,
6258    {
6259        #[inline]
6260        fn encode(
6261            self,
6262            encoder: &mut ___E,
6263            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6264            _: (),
6265        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6266            ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
6267        }
6268    }
6269
6270    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for RouterError
6271    where
6272        ___E: ?Sized,
6273    {
6274        #[inline]
6275        fn encode_ref(
6276            &self,
6277            encoder: &mut ___E,
6278            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6279            _: (),
6280        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6281            ::fidl_next::munge!(let crate::wire::RouterError { value } = out);
6282            let _ = value.write(::fidl_next::WireU32::from(match *self {
6283                Self::NotFound => 1,
6284
6285                Self::InvalidArgs => 2,
6286
6287                Self::NotSupported => 3,
6288
6289                Self::Internal => 4,
6290
6291                Self::UnknownOrdinal_(value) => value,
6292            }));
6293
6294            Ok(())
6295        }
6296    }
6297
6298    impl ::core::convert::From<crate::wire::RouterError> for RouterError {
6299        fn from(wire: crate::wire::RouterError) -> Self {
6300            match u32::from(wire.value) {
6301                1 => Self::NotFound,
6302
6303                2 => Self::InvalidArgs,
6304
6305                3 => Self::NotSupported,
6306
6307                4 => Self::Internal,
6308
6309                value => Self::UnknownOrdinal_(value),
6310            }
6311        }
6312    }
6313
6314    impl ::fidl_next::FromWire<crate::wire::RouterError> for RouterError {
6315        #[inline]
6316        fn from_wire(wire: crate::wire::RouterError) -> Self {
6317            Self::from(wire)
6318        }
6319    }
6320
6321    impl ::fidl_next::FromWireRef<crate::wire::RouterError> for RouterError {
6322        #[inline]
6323        fn from_wire_ref(wire: &crate::wire::RouterError) -> Self {
6324            Self::from(*wire)
6325        }
6326    }
6327
6328    #[derive(PartialEq, Debug)]
6329    pub enum DataRouterRouteResponse {
6330        Data(crate::natural::Data),
6331
6332        Unavailable(crate::natural::Unit),
6333    }
6334
6335    impl ::fidl_next::Encodable for DataRouterRouteResponse {
6336        type Encoded = crate::wire::DataRouterRouteResponse<'static>;
6337    }
6338
6339    unsafe impl<___E> ::fidl_next::Encode<___E> for DataRouterRouteResponse
6340    where
6341        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6342        ___E: ::fidl_next::Encoder,
6343        ___E: ::fidl_next::fuchsia::HandleEncoder,
6344    {
6345        #[inline]
6346        fn encode(
6347            self,
6348            encoder: &mut ___E,
6349            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6350            _: (),
6351        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6352            ::fidl_next::munge!(let crate::wire::DataRouterRouteResponse { raw, _phantom: _ } = out);
6353
6354            match self {
6355                Self::Data(value) => ::fidl_next::RawWireUnion::encode_as::<
6356                    ___E,
6357                    crate::natural::Data,
6358                >(value, 1, encoder, raw, ())?,
6359
6360                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as::<
6361                    ___E,
6362                    crate::natural::Unit,
6363                >(value, 2, encoder, raw, ())?,
6364            }
6365
6366            Ok(())
6367        }
6368    }
6369
6370    impl ::fidl_next::EncodableOption for DataRouterRouteResponse {
6371        type EncodedOption = crate::wire_optional::DataRouterRouteResponse<'static>;
6372    }
6373
6374    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DataRouterRouteResponse
6375    where
6376        ___E: ?Sized,
6377        DataRouterRouteResponse: ::fidl_next::Encode<___E>,
6378    {
6379        #[inline]
6380        fn encode_option(
6381            this: ::core::option::Option<Self>,
6382            encoder: &mut ___E,
6383            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6384            _: (),
6385        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6386            ::fidl_next::munge!(let crate::wire_optional::DataRouterRouteResponse { raw, _phantom: _ } = &mut *out);
6387
6388            if let Some(inner) = this {
6389                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
6390                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
6391            } else {
6392                ::fidl_next::RawWireUnion::encode_absent(raw);
6393            }
6394
6395            Ok(())
6396        }
6397    }
6398
6399    impl<'de> ::fidl_next::FromWire<crate::wire::DataRouterRouteResponse<'de>>
6400        for DataRouterRouteResponse
6401    {
6402        #[inline]
6403        fn from_wire(wire: crate::wire::DataRouterRouteResponse<'de>) -> Self {
6404            let wire = ::core::mem::ManuallyDrop::new(wire);
6405            match wire.raw.ordinal() {
6406                1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
6407                    wire.raw.get().read_unchecked::<crate::wire::Data<'de>>()
6408                })),
6409
6410                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
6411                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
6412                })),
6413
6414                _ => unsafe { ::core::hint::unreachable_unchecked() },
6415            }
6416        }
6417    }
6418
6419    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
6420        for DataRouterRouteResponse
6421    {
6422        #[inline]
6423        fn from_wire_option(
6424            wire: crate::wire_optional::DataRouterRouteResponse<'de>,
6425        ) -> ::core::option::Option<Self> {
6426            if let Some(inner) = wire.into_option() {
6427                Some(::fidl_next::FromWire::from_wire(inner))
6428            } else {
6429                None
6430            }
6431        }
6432    }
6433
6434    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::DataRouterRouteResponse<'de>>
6435        for Box<DataRouterRouteResponse>
6436    {
6437        #[inline]
6438        fn from_wire_option(
6439            wire: crate::wire_optional::DataRouterRouteResponse<'de>,
6440        ) -> ::core::option::Option<Self> {
6441            <DataRouterRouteResponse as ::fidl_next::FromWireOption<
6442                crate::wire_optional::DataRouterRouteResponse<'de>,
6443            >>::from_wire_option(wire)
6444            .map(Box::new)
6445        }
6446    }
6447
6448    #[derive(PartialEq, Clone, Debug)]
6449    pub struct DictionaryDrainIteratorGetNextRequest {
6450        pub start_id: u64,
6451
6452        pub limit: u32,
6453    }
6454
6455    impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest {
6456        type Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest;
6457    }
6458
6459    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextRequest
6460    where
6461        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6462    {
6463        #[inline]
6464        fn encode(
6465            self,
6466            encoder_: &mut ___E,
6467            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6468            _: (),
6469        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6470            ::fidl_next::munge! {
6471                let Self::Encoded {
6472                    start_id,
6473                    limit,
6474
6475                } = out_;
6476            }
6477
6478            ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
6479
6480            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6481
6482            ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
6483
6484            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6485
6486            Ok(())
6487        }
6488    }
6489
6490    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryDrainIteratorGetNextRequest
6491    where
6492        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6493    {
6494        #[inline]
6495        fn encode_ref(
6496            &self,
6497            encoder_: &mut ___E,
6498            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6499            _: (),
6500        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6501            ::fidl_next::munge! {
6502                let Self::Encoded {
6503
6504                    start_id,
6505                    limit,
6506
6507                } = out_;
6508            }
6509
6510            ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id, ())?;
6511
6512            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6513
6514            ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit, ())?;
6515
6516            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6517
6518            Ok(())
6519        }
6520    }
6521
6522    impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextRequest {
6523        type EncodedOption =
6524            ::fidl_next::WireBox<'static, crate::wire::DictionaryDrainIteratorGetNextRequest>;
6525    }
6526
6527    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextRequest
6528    where
6529        ___E: ::fidl_next::Encoder + ?Sized,
6530        DictionaryDrainIteratorGetNextRequest: ::fidl_next::Encode<___E>,
6531    {
6532        #[inline]
6533        fn encode_option(
6534            this: ::core::option::Option<Self>,
6535            encoder: &mut ___E,
6536            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6537            _: (),
6538        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6539            if let Some(inner) = this {
6540                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6541                ::fidl_next::WireBox::encode_present(out);
6542            } else {
6543                ::fidl_next::WireBox::encode_absent(out);
6544            }
6545
6546            Ok(())
6547        }
6548    }
6549
6550    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryDrainIteratorGetNextRequest
6551    where
6552        ___E: ::fidl_next::Encoder + ?Sized,
6553        DictionaryDrainIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
6554    {
6555        #[inline]
6556        fn encode_option_ref(
6557            this: ::core::option::Option<&Self>,
6558            encoder: &mut ___E,
6559            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6560            _: (),
6561        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6562            if let Some(inner) = this {
6563                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6564                ::fidl_next::WireBox::encode_present(out);
6565            } else {
6566                ::fidl_next::WireBox::encode_absent(out);
6567            }
6568
6569            Ok(())
6570        }
6571    }
6572
6573    impl ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextRequest>
6574        for DictionaryDrainIteratorGetNextRequest
6575    {
6576        #[inline]
6577        fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
6578            Self {
6579                start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
6580
6581                limit: ::fidl_next::FromWire::from_wire(wire.limit),
6582            }
6583        }
6584    }
6585
6586    impl ::fidl_next::FromWireRef<crate::wire::DictionaryDrainIteratorGetNextRequest>
6587        for DictionaryDrainIteratorGetNextRequest
6588    {
6589        #[inline]
6590        fn from_wire_ref(wire: &crate::wire::DictionaryDrainIteratorGetNextRequest) -> Self {
6591            Self {
6592                start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
6593
6594                limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
6595            }
6596        }
6597    }
6598
6599    #[derive(PartialEq, Debug)]
6600    pub struct DictionaryDrainIteratorGetNextResponse {
6601        pub items: ::std::vec::Vec<crate::natural::DictionaryItem>,
6602
6603        pub end_id: u64,
6604    }
6605
6606    impl ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse {
6607        type Encoded = crate::wire::DictionaryDrainIteratorGetNextResponse<'static>;
6608    }
6609
6610    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryDrainIteratorGetNextResponse
6611    where
6612        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6613        ___E: ::fidl_next::Encoder,
6614        ___E: ::fidl_next::fuchsia::HandleEncoder,
6615    {
6616        #[inline]
6617        fn encode(
6618            self,
6619            encoder_: &mut ___E,
6620            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6621            _: (),
6622        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6623            ::fidl_next::munge! {
6624                let Self::Encoded {
6625                    items,
6626                    end_id,
6627
6628                } = out_;
6629            }
6630
6631            ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
6632
6633            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
6634            ::fidl_next::Constrained::validate(_field, (128, ()))?;
6635
6636            ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
6637
6638            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
6639
6640            Ok(())
6641        }
6642    }
6643
6644    impl ::fidl_next::EncodableOption for DictionaryDrainIteratorGetNextResponse {
6645        type EncodedOption = ::fidl_next::WireBox<
6646            'static,
6647            crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
6648        >;
6649    }
6650
6651    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryDrainIteratorGetNextResponse
6652    where
6653        ___E: ::fidl_next::Encoder + ?Sized,
6654        DictionaryDrainIteratorGetNextResponse: ::fidl_next::Encode<___E>,
6655    {
6656        #[inline]
6657        fn encode_option(
6658            this: ::core::option::Option<Self>,
6659            encoder: &mut ___E,
6660            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6661            _: (),
6662        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6663            if let Some(inner) = this {
6664                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6665                ::fidl_next::WireBox::encode_present(out);
6666            } else {
6667                ::fidl_next::WireBox::encode_absent(out);
6668            }
6669
6670            Ok(())
6671        }
6672    }
6673
6674    impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryDrainIteratorGetNextResponse<'de>>
6675        for DictionaryDrainIteratorGetNextResponse
6676    {
6677        #[inline]
6678        fn from_wire(wire: crate::wire::DictionaryDrainIteratorGetNextResponse<'de>) -> Self {
6679            Self {
6680                items: ::fidl_next::FromWire::from_wire(wire.items),
6681
6682                end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
6683            }
6684        }
6685    }
6686
6687    #[derive(PartialEq, Clone, Debug)]
6688    pub struct DictionaryEnumerateIteratorGetNextRequest {
6689        pub start_id: u64,
6690
6691        pub limit: u32,
6692    }
6693
6694    impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest {
6695        type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
6696    }
6697
6698    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextRequest
6699    where
6700        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6701    {
6702        #[inline]
6703        fn encode(
6704            self,
6705            encoder_: &mut ___E,
6706            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6707            _: (),
6708        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6709            ::fidl_next::munge! {
6710                let Self::Encoded {
6711                    start_id,
6712                    limit,
6713
6714                } = out_;
6715            }
6716
6717            ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
6718
6719            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6720
6721            ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
6722
6723            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6724
6725            Ok(())
6726        }
6727    }
6728
6729    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryEnumerateIteratorGetNextRequest
6730    where
6731        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6732    {
6733        #[inline]
6734        fn encode_ref(
6735            &self,
6736            encoder_: &mut ___E,
6737            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6738            _: (),
6739        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6740            ::fidl_next::munge! {
6741                let Self::Encoded {
6742
6743                    start_id,
6744                    limit,
6745
6746                } = out_;
6747            }
6748
6749            ::fidl_next::EncodeRef::encode_ref(&self.start_id, encoder_, start_id, ())?;
6750
6751            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(start_id.as_mut_ptr()) };
6752
6753            ::fidl_next::EncodeRef::encode_ref(&self.limit, encoder_, limit, ())?;
6754
6755            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(limit.as_mut_ptr()) };
6756
6757            Ok(())
6758        }
6759    }
6760
6761    impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextRequest {
6762        type EncodedOption =
6763            ::fidl_next::WireBox<'static, crate::wire::DictionaryEnumerateIteratorGetNextRequest>;
6764    }
6765
6766    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextRequest
6767    where
6768        ___E: ::fidl_next::Encoder + ?Sized,
6769        DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::Encode<___E>,
6770    {
6771        #[inline]
6772        fn encode_option(
6773            this: ::core::option::Option<Self>,
6774            encoder: &mut ___E,
6775            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6776            _: (),
6777        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6778            if let Some(inner) = this {
6779                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6780                ::fidl_next::WireBox::encode_present(out);
6781            } else {
6782                ::fidl_next::WireBox::encode_absent(out);
6783            }
6784
6785            Ok(())
6786        }
6787    }
6788
6789    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for DictionaryEnumerateIteratorGetNextRequest
6790    where
6791        ___E: ::fidl_next::Encoder + ?Sized,
6792        DictionaryEnumerateIteratorGetNextRequest: ::fidl_next::EncodeRef<___E>,
6793    {
6794        #[inline]
6795        fn encode_option_ref(
6796            this: ::core::option::Option<&Self>,
6797            encoder: &mut ___E,
6798            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6799            _: (),
6800        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6801            if let Some(inner) = this {
6802                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6803                ::fidl_next::WireBox::encode_present(out);
6804            } else {
6805                ::fidl_next::WireBox::encode_absent(out);
6806            }
6807
6808            Ok(())
6809        }
6810    }
6811
6812    impl ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
6813        for DictionaryEnumerateIteratorGetNextRequest
6814    {
6815        #[inline]
6816        fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
6817            Self {
6818                start_id: ::fidl_next::FromWire::from_wire(wire.start_id),
6819
6820                limit: ::fidl_next::FromWire::from_wire(wire.limit),
6821            }
6822        }
6823    }
6824
6825    impl ::fidl_next::FromWireRef<crate::wire::DictionaryEnumerateIteratorGetNextRequest>
6826        for DictionaryEnumerateIteratorGetNextRequest
6827    {
6828        #[inline]
6829        fn from_wire_ref(wire: &crate::wire::DictionaryEnumerateIteratorGetNextRequest) -> Self {
6830            Self {
6831                start_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.start_id),
6832
6833                limit: ::fidl_next::FromWireRef::from_wire_ref(&wire.limit),
6834            }
6835        }
6836    }
6837
6838    #[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"]
6839    #[derive(PartialEq, Debug)]
6840    pub struct DictionaryOptionalItem {
6841        pub key: ::std::string::String,
6842
6843        pub value: ::core::option::Option<::std::boxed::Box<crate::natural::WrappedCapabilityId>>,
6844    }
6845
6846    impl ::fidl_next::Encodable for DictionaryOptionalItem {
6847        type Encoded = crate::wire::DictionaryOptionalItem<'static>;
6848    }
6849
6850    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryOptionalItem
6851    where
6852        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6853        ___E: ::fidl_next::Encoder,
6854        ___E: ::fidl_next::fuchsia::HandleEncoder,
6855    {
6856        #[inline]
6857        fn encode(
6858            self,
6859            encoder_: &mut ___E,
6860            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6861            _: (),
6862        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6863            ::fidl_next::munge! {
6864                let Self::Encoded {
6865                    key,
6866                    value,
6867
6868                } = out_;
6869            }
6870
6871            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
6872
6873            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(key.as_mut_ptr()) };
6874            ::fidl_next::Constrained::validate(_field, 255)?;
6875
6876            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
6877
6878            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
6879
6880            Ok(())
6881        }
6882    }
6883
6884    impl ::fidl_next::EncodableOption for DictionaryOptionalItem {
6885        type EncodedOption =
6886            ::fidl_next::WireBox<'static, crate::wire::DictionaryOptionalItem<'static>>;
6887    }
6888
6889    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryOptionalItem
6890    where
6891        ___E: ::fidl_next::Encoder + ?Sized,
6892        DictionaryOptionalItem: ::fidl_next::Encode<___E>,
6893    {
6894        #[inline]
6895        fn encode_option(
6896            this: ::core::option::Option<Self>,
6897            encoder: &mut ___E,
6898            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6899            _: (),
6900        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6901            if let Some(inner) = this {
6902                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6903                ::fidl_next::WireBox::encode_present(out);
6904            } else {
6905                ::fidl_next::WireBox::encode_absent(out);
6906            }
6907
6908            Ok(())
6909        }
6910    }
6911
6912    impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryOptionalItem<'de>>
6913        for DictionaryOptionalItem
6914    {
6915        #[inline]
6916        fn from_wire(wire: crate::wire::DictionaryOptionalItem<'de>) -> Self {
6917            Self {
6918                key: ::fidl_next::FromWire::from_wire(wire.key),
6919
6920                value: ::fidl_next::FromWire::from_wire(wire.value),
6921            }
6922        }
6923    }
6924
6925    #[derive(PartialEq, Debug)]
6926    pub struct DictionaryEnumerateIteratorGetNextResponse {
6927        pub items: ::std::vec::Vec<crate::natural::DictionaryOptionalItem>,
6928
6929        pub end_id: u64,
6930    }
6931
6932    impl ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse {
6933        type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>;
6934    }
6935
6936    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryEnumerateIteratorGetNextResponse
6937    where
6938        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6939        ___E: ::fidl_next::Encoder,
6940        ___E: ::fidl_next::fuchsia::HandleEncoder,
6941    {
6942        #[inline]
6943        fn encode(
6944            self,
6945            encoder_: &mut ___E,
6946            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
6947            _: (),
6948        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6949            ::fidl_next::munge! {
6950                let Self::Encoded {
6951                    items,
6952                    end_id,
6953
6954                } = out_;
6955            }
6956
6957            ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
6958
6959            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(items.as_mut_ptr()) };
6960            ::fidl_next::Constrained::validate(_field, (128, ()))?;
6961
6962            ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
6963
6964            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(end_id.as_mut_ptr()) };
6965
6966            Ok(())
6967        }
6968    }
6969
6970    impl ::fidl_next::EncodableOption for DictionaryEnumerateIteratorGetNextResponse {
6971        type EncodedOption = ::fidl_next::WireBox<
6972            'static,
6973            crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
6974        >;
6975    }
6976
6977    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryEnumerateIteratorGetNextResponse
6978    where
6979        ___E: ::fidl_next::Encoder + ?Sized,
6980        DictionaryEnumerateIteratorGetNextResponse: ::fidl_next::Encode<___E>,
6981    {
6982        #[inline]
6983        fn encode_option(
6984            this: ::core::option::Option<Self>,
6985            encoder: &mut ___E,
6986            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
6987            _: (),
6988        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6989            if let Some(inner) = this {
6990                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
6991                ::fidl_next::WireBox::encode_present(out);
6992            } else {
6993                ::fidl_next::WireBox::encode_absent(out);
6994            }
6995
6996            Ok(())
6997        }
6998    }
6999
7000    impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>>
7001        for DictionaryEnumerateIteratorGetNextResponse
7002    {
7003        #[inline]
7004        fn from_wire(wire: crate::wire::DictionaryEnumerateIteratorGetNextResponse<'de>) -> Self {
7005            Self {
7006                items: ::fidl_next::FromWire::from_wire(wire.items),
7007
7008                end_id: ::fidl_next::FromWire::from_wire(wire.end_id),
7009            }
7010        }
7011    }
7012
7013    #[doc = " Error returned from [CapabilityStore/Dictionary*] methods.\n"]
7014    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
7015    #[repr(u32)]
7016    pub enum DictionaryError {
7017        NotFound = 1,
7018        AlreadyExists = 2,
7019        BadCapability = 3,
7020        InvalidKey = 4,
7021        NotCloneable = 5,
7022        UnknownOrdinal_(u32) = 6,
7023    }
7024
7025    impl ::fidl_next::Encodable for DictionaryError {
7026        type Encoded = crate::wire::DictionaryError;
7027    }
7028    impl ::std::convert::From<u32> for DictionaryError {
7029        fn from(value: u32) -> Self {
7030            match value {
7031                1 => Self::NotFound,
7032                2 => Self::AlreadyExists,
7033                3 => Self::BadCapability,
7034                4 => Self::InvalidKey,
7035                5 => Self::NotCloneable,
7036
7037                _ => Self::UnknownOrdinal_(value),
7038            }
7039        }
7040    }
7041
7042    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryError
7043    where
7044        ___E: ?Sized,
7045    {
7046        #[inline]
7047        fn encode(
7048            self,
7049            encoder: &mut ___E,
7050            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7051            _: (),
7052        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7053            ::fidl_next::EncodeRef::encode_ref(&self, encoder, out, ())
7054        }
7055    }
7056
7057    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for DictionaryError
7058    where
7059        ___E: ?Sized,
7060    {
7061        #[inline]
7062        fn encode_ref(
7063            &self,
7064            encoder: &mut ___E,
7065            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7066            _: (),
7067        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7068            ::fidl_next::munge!(let crate::wire::DictionaryError { value } = out);
7069            let _ = value.write(::fidl_next::WireU32::from(match *self {
7070                Self::NotFound => 1,
7071
7072                Self::AlreadyExists => 2,
7073
7074                Self::BadCapability => 3,
7075
7076                Self::InvalidKey => 4,
7077
7078                Self::NotCloneable => 5,
7079
7080                Self::UnknownOrdinal_(value) => value,
7081            }));
7082
7083            Ok(())
7084        }
7085    }
7086
7087    impl ::core::convert::From<crate::wire::DictionaryError> for DictionaryError {
7088        fn from(wire: crate::wire::DictionaryError) -> Self {
7089            match u32::from(wire.value) {
7090                1 => Self::NotFound,
7091
7092                2 => Self::AlreadyExists,
7093
7094                3 => Self::BadCapability,
7095
7096                4 => Self::InvalidKey,
7097
7098                5 => Self::NotCloneable,
7099
7100                value => Self::UnknownOrdinal_(value),
7101            }
7102        }
7103    }
7104
7105    impl ::fidl_next::FromWire<crate::wire::DictionaryError> for DictionaryError {
7106        #[inline]
7107        fn from_wire(wire: crate::wire::DictionaryError) -> Self {
7108            Self::from(wire)
7109        }
7110    }
7111
7112    impl ::fidl_next::FromWireRef<crate::wire::DictionaryError> for DictionaryError {
7113        #[inline]
7114        fn from_wire_ref(wire: &crate::wire::DictionaryError) -> Self {
7115            Self::from(*wire)
7116        }
7117    }
7118
7119    #[derive(PartialEq, Debug)]
7120    pub struct DictionaryKeysIteratorGetNextResponse {
7121        pub keys: ::std::vec::Vec<::std::string::String>,
7122    }
7123
7124    impl ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse {
7125        type Encoded = crate::wire::DictionaryKeysIteratorGetNextResponse<'static>;
7126    }
7127
7128    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse
7129    where
7130        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7131        ___E: ::fidl_next::Encoder,
7132        ___E: ::fidl_next::fuchsia::HandleEncoder,
7133    {
7134        #[inline]
7135        fn encode(
7136            self,
7137            encoder_: &mut ___E,
7138            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7139            _: (),
7140        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7141            ::fidl_next::munge! {
7142                let Self::Encoded {
7143                    keys,
7144
7145                } = out_;
7146            }
7147
7148            ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
7149
7150            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(keys.as_mut_ptr()) };
7151            ::fidl_next::Constrained::validate(_field, (128, 255))?;
7152
7153            Ok(())
7154        }
7155    }
7156
7157    impl ::fidl_next::EncodableOption for DictionaryKeysIteratorGetNextResponse {
7158        type EncodedOption = ::fidl_next::WireBox<
7159            'static,
7160            crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
7161        >;
7162    }
7163
7164    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryKeysIteratorGetNextResponse
7165    where
7166        ___E: ::fidl_next::Encoder + ?Sized,
7167        DictionaryKeysIteratorGetNextResponse: ::fidl_next::Encode<___E>,
7168    {
7169        #[inline]
7170        fn encode_option(
7171            this: ::core::option::Option<Self>,
7172            encoder: &mut ___E,
7173            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7174            _: (),
7175        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7176            if let Some(inner) = this {
7177                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7178                ::fidl_next::WireBox::encode_present(out);
7179            } else {
7180                ::fidl_next::WireBox::encode_absent(out);
7181            }
7182
7183            Ok(())
7184        }
7185    }
7186
7187    impl<'de> ::fidl_next::FromWire<crate::wire::DictionaryKeysIteratorGetNextResponse<'de>>
7188        for DictionaryKeysIteratorGetNextResponse
7189    {
7190        #[inline]
7191        fn from_wire(wire: crate::wire::DictionaryKeysIteratorGetNextResponse<'de>) -> Self {
7192            Self { keys: ::fidl_next::FromWire::from_wire(wire.keys) }
7193        }
7194    }
7195
7196    #[derive(PartialEq, Debug)]
7197    pub enum DictionaryRouterRouteResponse {
7198        Dictionary(crate::natural::DictionaryRef),
7199
7200        Unavailable(crate::natural::Unit),
7201    }
7202
7203    impl ::fidl_next::Encodable for DictionaryRouterRouteResponse {
7204        type Encoded = crate::wire::DictionaryRouterRouteResponse;
7205    }
7206
7207    unsafe impl<___E> ::fidl_next::Encode<___E> for DictionaryRouterRouteResponse
7208    where
7209        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7210        ___E: ::fidl_next::fuchsia::HandleEncoder,
7211    {
7212        #[inline]
7213        fn encode(
7214            self,
7215            encoder: &mut ___E,
7216            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7217            _: (),
7218        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7219            ::fidl_next::munge!(let crate::wire::DictionaryRouterRouteResponse { raw, _phantom: _ } = out);
7220
7221            match self {
7222                Self::Dictionary(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7223                    ___E,
7224                    crate::natural::DictionaryRef,
7225                >(value, 1, encoder, raw, ())?,
7226
7227                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7228                    ___E,
7229                    crate::natural::Unit,
7230                >(value, 2, encoder, raw, ())?,
7231            }
7232
7233            Ok(())
7234        }
7235    }
7236
7237    impl ::fidl_next::EncodableOption for DictionaryRouterRouteResponse {
7238        type EncodedOption = crate::wire_optional::DictionaryRouterRouteResponse;
7239    }
7240
7241    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DictionaryRouterRouteResponse
7242    where
7243        ___E: ?Sized,
7244        DictionaryRouterRouteResponse: ::fidl_next::Encode<___E>,
7245    {
7246        #[inline]
7247        fn encode_option(
7248            this: ::core::option::Option<Self>,
7249            encoder: &mut ___E,
7250            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7251            _: (),
7252        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7253            ::fidl_next::munge!(let crate::wire_optional::DictionaryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7254
7255            if let Some(inner) = this {
7256                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7257                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7258            } else {
7259                ::fidl_next::RawWireUnion::encode_absent(raw);
7260            }
7261
7262            Ok(())
7263        }
7264    }
7265
7266    impl ::fidl_next::FromWire<crate::wire::DictionaryRouterRouteResponse>
7267        for DictionaryRouterRouteResponse
7268    {
7269        #[inline]
7270        fn from_wire(wire: crate::wire::DictionaryRouterRouteResponse) -> Self {
7271            let wire = ::core::mem::ManuallyDrop::new(wire);
7272            match wire.raw.ordinal() {
7273                1 => Self::Dictionary(::fidl_next::FromWire::from_wire(unsafe {
7274                    wire.raw.get().read_unchecked::<crate::wire::DictionaryRef>()
7275                })),
7276
7277                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7278                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
7279                })),
7280
7281                _ => unsafe { ::core::hint::unreachable_unchecked() },
7282            }
7283        }
7284    }
7285
7286    impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
7287        for DictionaryRouterRouteResponse
7288    {
7289        #[inline]
7290        fn from_wire_option(
7291            wire: crate::wire_optional::DictionaryRouterRouteResponse,
7292        ) -> ::core::option::Option<Self> {
7293            if let Some(inner) = wire.into_option() {
7294                Some(::fidl_next::FromWire::from_wire(inner))
7295            } else {
7296                None
7297            }
7298        }
7299    }
7300
7301    impl ::fidl_next::FromWireOption<crate::wire_optional::DictionaryRouterRouteResponse>
7302        for Box<DictionaryRouterRouteResponse>
7303    {
7304        #[inline]
7305        fn from_wire_option(
7306            wire: crate::wire_optional::DictionaryRouterRouteResponse,
7307        ) -> ::core::option::Option<Self> {
7308            <DictionaryRouterRouteResponse as ::fidl_next::FromWireOption<
7309                crate::wire_optional::DictionaryRouterRouteResponse,
7310            >>::from_wire_option(wire)
7311            .map(Box::new)
7312        }
7313    }
7314
7315    #[derive(PartialEq, Debug)]
7316    pub enum DirConnectorRouterRouteResponse {
7317        DirConnector(crate::natural::DirConnector),
7318
7319        Unavailable(crate::natural::Unit),
7320    }
7321
7322    impl ::fidl_next::Encodable for DirConnectorRouterRouteResponse {
7323        type Encoded = crate::wire::DirConnectorRouterRouteResponse;
7324    }
7325
7326    unsafe impl<___E> ::fidl_next::Encode<___E> for DirConnectorRouterRouteResponse
7327    where
7328        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7329        ___E: ::fidl_next::fuchsia::HandleEncoder,
7330    {
7331        #[inline]
7332        fn encode(
7333            self,
7334            encoder: &mut ___E,
7335            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7336            _: (),
7337        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7338            ::fidl_next::munge!(let crate::wire::DirConnectorRouterRouteResponse { raw, _phantom: _ } = out);
7339
7340            match self {
7341                Self::DirConnector(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7342                    ___E,
7343                    crate::natural::DirConnector,
7344                >(value, 1, encoder, raw, ())?,
7345
7346                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7347                    ___E,
7348                    crate::natural::Unit,
7349                >(value, 2, encoder, raw, ())?,
7350            }
7351
7352            Ok(())
7353        }
7354    }
7355
7356    impl ::fidl_next::EncodableOption for DirConnectorRouterRouteResponse {
7357        type EncodedOption = crate::wire_optional::DirConnectorRouterRouteResponse;
7358    }
7359
7360    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirConnectorRouterRouteResponse
7361    where
7362        ___E: ?Sized,
7363        DirConnectorRouterRouteResponse: ::fidl_next::Encode<___E>,
7364    {
7365        #[inline]
7366        fn encode_option(
7367            this: ::core::option::Option<Self>,
7368            encoder: &mut ___E,
7369            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7370            _: (),
7371        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7372            ::fidl_next::munge!(let crate::wire_optional::DirConnectorRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7373
7374            if let Some(inner) = this {
7375                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7376                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7377            } else {
7378                ::fidl_next::RawWireUnion::encode_absent(raw);
7379            }
7380
7381            Ok(())
7382        }
7383    }
7384
7385    impl ::fidl_next::FromWire<crate::wire::DirConnectorRouterRouteResponse>
7386        for DirConnectorRouterRouteResponse
7387    {
7388        #[inline]
7389        fn from_wire(wire: crate::wire::DirConnectorRouterRouteResponse) -> Self {
7390            let wire = ::core::mem::ManuallyDrop::new(wire);
7391            match wire.raw.ordinal() {
7392                1 => Self::DirConnector(::fidl_next::FromWire::from_wire(unsafe {
7393                    wire.raw.get().read_unchecked::<crate::wire::DirConnector>()
7394                })),
7395
7396                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7397                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
7398                })),
7399
7400                _ => unsafe { ::core::hint::unreachable_unchecked() },
7401            }
7402        }
7403    }
7404
7405    impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
7406        for DirConnectorRouterRouteResponse
7407    {
7408        #[inline]
7409        fn from_wire_option(
7410            wire: crate::wire_optional::DirConnectorRouterRouteResponse,
7411        ) -> ::core::option::Option<Self> {
7412            if let Some(inner) = wire.into_option() {
7413                Some(::fidl_next::FromWire::from_wire(inner))
7414            } else {
7415                None
7416            }
7417        }
7418    }
7419
7420    impl ::fidl_next::FromWireOption<crate::wire_optional::DirConnectorRouterRouteResponse>
7421        for Box<DirConnectorRouterRouteResponse>
7422    {
7423        #[inline]
7424        fn from_wire_option(
7425            wire: crate::wire_optional::DirConnectorRouterRouteResponse,
7426        ) -> ::core::option::Option<Self> {
7427            <DirConnectorRouterRouteResponse as ::fidl_next::FromWireOption<
7428                crate::wire_optional::DirConnectorRouterRouteResponse,
7429            >>::from_wire_option(wire)
7430            .map(Box::new)
7431        }
7432    }
7433
7434    #[derive(PartialEq, Debug)]
7435    pub enum DirEntryRouterRouteResponse {
7436        DirEntry(crate::natural::DirEntry),
7437
7438        Unavailable(crate::natural::Unit),
7439    }
7440
7441    impl ::fidl_next::Encodable for DirEntryRouterRouteResponse {
7442        type Encoded = crate::wire::DirEntryRouterRouteResponse;
7443    }
7444
7445    unsafe impl<___E> ::fidl_next::Encode<___E> for DirEntryRouterRouteResponse
7446    where
7447        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7448        ___E: ::fidl_next::fuchsia::HandleEncoder,
7449    {
7450        #[inline]
7451        fn encode(
7452            self,
7453            encoder: &mut ___E,
7454            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7455            _: (),
7456        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7457            ::fidl_next::munge!(let crate::wire::DirEntryRouterRouteResponse { raw, _phantom: _ } = out);
7458
7459            match self {
7460                Self::DirEntry(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7461                    ___E,
7462                    crate::natural::DirEntry,
7463                >(value, 1, encoder, raw, ())?,
7464
7465                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7466                    ___E,
7467                    crate::natural::Unit,
7468                >(value, 2, encoder, raw, ())?,
7469            }
7470
7471            Ok(())
7472        }
7473    }
7474
7475    impl ::fidl_next::EncodableOption for DirEntryRouterRouteResponse {
7476        type EncodedOption = crate::wire_optional::DirEntryRouterRouteResponse;
7477    }
7478
7479    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirEntryRouterRouteResponse
7480    where
7481        ___E: ?Sized,
7482        DirEntryRouterRouteResponse: ::fidl_next::Encode<___E>,
7483    {
7484        #[inline]
7485        fn encode_option(
7486            this: ::core::option::Option<Self>,
7487            encoder: &mut ___E,
7488            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7489            _: (),
7490        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7491            ::fidl_next::munge!(let crate::wire_optional::DirEntryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7492
7493            if let Some(inner) = this {
7494                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7495                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7496            } else {
7497                ::fidl_next::RawWireUnion::encode_absent(raw);
7498            }
7499
7500            Ok(())
7501        }
7502    }
7503
7504    impl ::fidl_next::FromWire<crate::wire::DirEntryRouterRouteResponse>
7505        for DirEntryRouterRouteResponse
7506    {
7507        #[inline]
7508        fn from_wire(wire: crate::wire::DirEntryRouterRouteResponse) -> Self {
7509            let wire = ::core::mem::ManuallyDrop::new(wire);
7510            match wire.raw.ordinal() {
7511                1 => Self::DirEntry(::fidl_next::FromWire::from_wire(unsafe {
7512                    wire.raw.get().read_unchecked::<crate::wire::DirEntry>()
7513                })),
7514
7515                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7516                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
7517                })),
7518
7519                _ => unsafe { ::core::hint::unreachable_unchecked() },
7520            }
7521        }
7522    }
7523
7524    impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
7525        for DirEntryRouterRouteResponse
7526    {
7527        #[inline]
7528        fn from_wire_option(
7529            wire: crate::wire_optional::DirEntryRouterRouteResponse,
7530        ) -> ::core::option::Option<Self> {
7531            if let Some(inner) = wire.into_option() {
7532                Some(::fidl_next::FromWire::from_wire(inner))
7533            } else {
7534                None
7535            }
7536        }
7537    }
7538
7539    impl ::fidl_next::FromWireOption<crate::wire_optional::DirEntryRouterRouteResponse>
7540        for Box<DirEntryRouterRouteResponse>
7541    {
7542        #[inline]
7543        fn from_wire_option(
7544            wire: crate::wire_optional::DirEntryRouterRouteResponse,
7545        ) -> ::core::option::Option<Self> {
7546            <DirEntryRouterRouteResponse as ::fidl_next::FromWireOption<
7547                crate::wire_optional::DirEntryRouterRouteResponse,
7548            >>::from_wire_option(wire)
7549            .map(Box::new)
7550        }
7551    }
7552
7553    #[derive(PartialEq, Debug)]
7554    #[repr(C)]
7555    pub struct DirReceiverReceiveRequest {
7556        pub channel: ::fidl_next::ServerEnd<
7557            ::fidl_next_fuchsia_io::Directory,
7558            ::fidl_next::fuchsia::zx::Channel,
7559        >,
7560    }
7561
7562    impl ::fidl_next::Encodable for DirReceiverReceiveRequest {
7563        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7564            Self,
7565            crate::wire::DirReceiverReceiveRequest,
7566        > = unsafe {
7567            ::fidl_next::CopyOptimization::enable_if(
7568                true && <::fidl_next::ServerEnd<
7569                    ::fidl_next_fuchsia_io::Directory,
7570                    ::fidl_next::fuchsia::zx::Channel,
7571                > as ::fidl_next::Encodable>::COPY_OPTIMIZATION
7572                    .is_enabled(),
7573            )
7574        };
7575
7576        type Encoded = crate::wire::DirReceiverReceiveRequest;
7577    }
7578
7579    unsafe impl<___E> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest
7580    where
7581        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7582        ___E: ::fidl_next::fuchsia::HandleEncoder,
7583    {
7584        #[inline]
7585        fn encode(
7586            self,
7587            encoder_: &mut ___E,
7588            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7589            _: (),
7590        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7591            ::fidl_next::munge! {
7592                let Self::Encoded {
7593                    channel,
7594
7595                } = out_;
7596            }
7597
7598            ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7599
7600            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
7601
7602            Ok(())
7603        }
7604    }
7605
7606    impl ::fidl_next::EncodableOption for DirReceiverReceiveRequest {
7607        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::DirReceiverReceiveRequest>;
7608    }
7609
7610    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirReceiverReceiveRequest
7611    where
7612        ___E: ::fidl_next::Encoder + ?Sized,
7613        DirReceiverReceiveRequest: ::fidl_next::Encode<___E>,
7614    {
7615        #[inline]
7616        fn encode_option(
7617            this: ::core::option::Option<Self>,
7618            encoder: &mut ___E,
7619            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7620            _: (),
7621        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7622            if let Some(inner) = this {
7623                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7624                ::fidl_next::WireBox::encode_present(out);
7625            } else {
7626                ::fidl_next::WireBox::encode_absent(out);
7627            }
7628
7629            Ok(())
7630        }
7631    }
7632
7633    impl ::fidl_next::FromWire<crate::wire::DirReceiverReceiveRequest> for DirReceiverReceiveRequest {
7634        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7635            crate::wire::DirReceiverReceiveRequest,
7636            Self,
7637        > = unsafe {
7638            ::fidl_next::CopyOptimization::enable_if(
7639                true && <::fidl_next::ServerEnd<
7640                    ::fidl_next_fuchsia_io::Directory,
7641                    ::fidl_next::fuchsia::zx::Channel,
7642                > as ::fidl_next::FromWire<
7643                    ::fidl_next::ServerEnd<
7644                        ::fidl_next_fuchsia_io::Directory,
7645                        ::fidl_next::fuchsia::WireChannel,
7646                    >,
7647                >>::COPY_OPTIMIZATION
7648                    .is_enabled(),
7649            )
7650        };
7651
7652        #[inline]
7653        fn from_wire(wire: crate::wire::DirReceiverReceiveRequest) -> Self {
7654            Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
7655        }
7656    }
7657
7658    #[derive(PartialEq, Debug)]
7659    pub enum DirectoryRouterRouteResponse {
7660        Directory(
7661            ::fidl_next::ClientEnd<
7662                ::fidl_next_fuchsia_io::Directory,
7663                ::fidl_next::fuchsia::zx::Channel,
7664            >,
7665        ),
7666
7667        Unavailable(crate::natural::Unit),
7668    }
7669
7670    impl ::fidl_next::Encodable for DirectoryRouterRouteResponse {
7671        type Encoded = crate::wire::DirectoryRouterRouteResponse;
7672    }
7673
7674    unsafe impl<___E> ::fidl_next::Encode<___E> for DirectoryRouterRouteResponse
7675    where
7676        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7677        ___E: ::fidl_next::fuchsia::HandleEncoder,
7678    {
7679        #[inline]
7680        fn encode(
7681            self,
7682            encoder: &mut ___E,
7683            out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7684            _: (),
7685        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7686            ::fidl_next::munge!(let crate::wire::DirectoryRouterRouteResponse { raw, _phantom: _ } = out);
7687
7688            match self {
7689                Self::Directory(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7690                    ___E,
7691                    ::fidl_next::ClientEnd<
7692                        ::fidl_next_fuchsia_io::Directory,
7693                        ::fidl_next::fuchsia::zx::Channel,
7694                    >,
7695                >(value, 1, encoder, raw, ())?,
7696
7697                Self::Unavailable(value) => ::fidl_next::RawWireUnion::encode_as_static::<
7698                    ___E,
7699                    crate::natural::Unit,
7700                >(value, 2, encoder, raw, ())?,
7701            }
7702
7703            Ok(())
7704        }
7705    }
7706
7707    impl ::fidl_next::EncodableOption for DirectoryRouterRouteResponse {
7708        type EncodedOption = crate::wire_optional::DirectoryRouterRouteResponse;
7709    }
7710
7711    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for DirectoryRouterRouteResponse
7712    where
7713        ___E: ?Sized,
7714        DirectoryRouterRouteResponse: ::fidl_next::Encode<___E>,
7715    {
7716        #[inline]
7717        fn encode_option(
7718            this: ::core::option::Option<Self>,
7719            encoder: &mut ___E,
7720            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7721            _: (),
7722        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7723            ::fidl_next::munge!(let crate::wire_optional::DirectoryRouterRouteResponse { raw, _phantom: _ } = &mut *out);
7724
7725            if let Some(inner) = this {
7726                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
7727                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
7728            } else {
7729                ::fidl_next::RawWireUnion::encode_absent(raw);
7730            }
7731
7732            Ok(())
7733        }
7734    }
7735
7736    impl ::fidl_next::FromWire<crate::wire::DirectoryRouterRouteResponse>
7737        for DirectoryRouterRouteResponse
7738    {
7739        #[inline]
7740        fn from_wire(wire: crate::wire::DirectoryRouterRouteResponse) -> Self {
7741            let wire = ::core::mem::ManuallyDrop::new(wire);
7742            match wire.raw.ordinal() {
7743                1 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
7744                    wire.raw.get().read_unchecked::<::fidl_next::ClientEnd<
7745                        ::fidl_next_fuchsia_io::Directory,
7746                        ::fidl_next::fuchsia::WireChannel,
7747                    >>()
7748                })),
7749
7750                2 => Self::Unavailable(::fidl_next::FromWire::from_wire(unsafe {
7751                    wire.raw.get().read_unchecked::<crate::wire::Unit>()
7752                })),
7753
7754                _ => unsafe { ::core::hint::unreachable_unchecked() },
7755            }
7756        }
7757    }
7758
7759    impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
7760        for DirectoryRouterRouteResponse
7761    {
7762        #[inline]
7763        fn from_wire_option(
7764            wire: crate::wire_optional::DirectoryRouterRouteResponse,
7765        ) -> ::core::option::Option<Self> {
7766            if let Some(inner) = wire.into_option() {
7767                Some(::fidl_next::FromWire::from_wire(inner))
7768            } else {
7769                None
7770            }
7771        }
7772    }
7773
7774    impl ::fidl_next::FromWireOption<crate::wire_optional::DirectoryRouterRouteResponse>
7775        for Box<DirectoryRouterRouteResponse>
7776    {
7777        #[inline]
7778        fn from_wire_option(
7779            wire: crate::wire_optional::DirectoryRouterRouteResponse,
7780        ) -> ::core::option::Option<Self> {
7781            <DirectoryRouterRouteResponse as ::fidl_next::FromWireOption<
7782                crate::wire_optional::DirectoryRouterRouteResponse,
7783            >>::from_wire_option(wire)
7784            .map(Box::new)
7785        }
7786    }
7787
7788    #[doc = " Contains a protocol open request.\n"]
7789    #[derive(PartialEq, Debug)]
7790    #[repr(C)]
7791    pub struct ProtocolPayload {
7792        pub channel: ::fidl_next::fuchsia::zx::Channel,
7793    }
7794
7795    impl ::fidl_next::Encodable for ProtocolPayload {
7796        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::ProtocolPayload> = unsafe {
7797            ::fidl_next::CopyOptimization::enable_if(
7798            true
7799
7800                && <
7801                    ::fidl_next::fuchsia::zx::Channel as ::fidl_next::Encodable
7802                >::COPY_OPTIMIZATION.is_enabled()
7803
7804        )
7805        };
7806
7807        type Encoded = crate::wire::ProtocolPayload;
7808    }
7809
7810    unsafe impl<___E> ::fidl_next::Encode<___E> for ProtocolPayload
7811    where
7812        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7813        ___E: ::fidl_next::fuchsia::HandleEncoder,
7814    {
7815        #[inline]
7816        fn encode(
7817            self,
7818            encoder_: &mut ___E,
7819            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7820            _: (),
7821        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7822            ::fidl_next::munge! {
7823                let Self::Encoded {
7824                    channel,
7825
7826                } = out_;
7827            }
7828
7829            ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
7830
7831            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(channel.as_mut_ptr()) };
7832
7833            Ok(())
7834        }
7835    }
7836
7837    impl ::fidl_next::EncodableOption for ProtocolPayload {
7838        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::ProtocolPayload>;
7839    }
7840
7841    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ProtocolPayload
7842    where
7843        ___E: ::fidl_next::Encoder + ?Sized,
7844        ProtocolPayload: ::fidl_next::Encode<___E>,
7845    {
7846        #[inline]
7847        fn encode_option(
7848            this: ::core::option::Option<Self>,
7849            encoder: &mut ___E,
7850            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7851            _: (),
7852        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7853            if let Some(inner) = this {
7854                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7855                ::fidl_next::WireBox::encode_present(out);
7856            } else {
7857                ::fidl_next::WireBox::encode_absent(out);
7858            }
7859
7860            Ok(())
7861        }
7862    }
7863
7864    impl ::fidl_next::FromWire<crate::wire::ProtocolPayload> for ProtocolPayload {
7865        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::ProtocolPayload, Self> = unsafe {
7866            ::fidl_next::CopyOptimization::enable_if(
7867                true && <::fidl_next::fuchsia::zx::Channel as ::fidl_next::FromWire<
7868                    ::fidl_next::fuchsia::WireChannel,
7869                >>::COPY_OPTIMIZATION
7870                    .is_enabled(),
7871            )
7872        };
7873
7874        #[inline]
7875        fn from_wire(wire: crate::wire::ProtocolPayload) -> Self {
7876            Self { channel: ::fidl_next::FromWire::from_wire(wire.channel) }
7877        }
7878    }
7879
7880    #[derive(PartialEq, Clone, Debug)]
7881    #[repr(C)]
7882    pub struct Unavailable {}
7883
7884    impl ::fidl_next::Encodable for Unavailable {
7885        type Encoded = crate::wire::Unavailable;
7886    }
7887
7888    unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
7889    where
7890        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7891    {
7892        #[inline]
7893        fn encode(
7894            self,
7895            encoder_: &mut ___E,
7896            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7897            _: (),
7898        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7899            *out_ = ::core::mem::MaybeUninit::zeroed();
7900
7901            Ok(())
7902        }
7903    }
7904
7905    unsafe impl<___E> ::fidl_next::EncodeRef<___E> for Unavailable
7906    where
7907        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7908    {
7909        #[inline]
7910        fn encode_ref(
7911            &self,
7912            encoder_: &mut ___E,
7913            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
7914            _: (),
7915        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7916            ::fidl_next::munge! {
7917                let Self::Encoded {
7918
7919                        _empty,
7920
7921
7922                } = out_;
7923            }
7924
7925            Ok(())
7926        }
7927    }
7928
7929    impl ::fidl_next::EncodableOption for Unavailable {
7930        type EncodedOption = ::fidl_next::WireBox<'static, crate::wire::Unavailable>;
7931    }
7932
7933    unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Unavailable
7934    where
7935        ___E: ::fidl_next::Encoder + ?Sized,
7936        Unavailable: ::fidl_next::Encode<___E>,
7937    {
7938        #[inline]
7939        fn encode_option(
7940            this: ::core::option::Option<Self>,
7941            encoder: &mut ___E,
7942            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7943            _: (),
7944        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7945            if let Some(inner) = this {
7946                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7947                ::fidl_next::WireBox::encode_present(out);
7948            } else {
7949                ::fidl_next::WireBox::encode_absent(out);
7950            }
7951
7952            Ok(())
7953        }
7954    }
7955
7956    unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for Unavailable
7957    where
7958        ___E: ::fidl_next::Encoder + ?Sized,
7959        Unavailable: ::fidl_next::EncodeRef<___E>,
7960    {
7961        #[inline]
7962        fn encode_option_ref(
7963            this: ::core::option::Option<&Self>,
7964            encoder: &mut ___E,
7965            out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
7966            _: (),
7967        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7968            if let Some(inner) = this {
7969                ::fidl_next::EncoderExt::encode_next(encoder, inner, ())?;
7970                ::fidl_next::WireBox::encode_present(out);
7971            } else {
7972                ::fidl_next::WireBox::encode_absent(out);
7973            }
7974
7975            Ok(())
7976        }
7977    }
7978
7979    impl ::fidl_next::FromWire<crate::wire::Unavailable> for Unavailable {
7980        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::Unavailable, Self> =
7981            unsafe { ::fidl_next::CopyOptimization::enable_if(true) };
7982
7983        #[inline]
7984        fn from_wire(wire: crate::wire::Unavailable) -> Self {
7985            Self {}
7986        }
7987    }
7988
7989    impl ::fidl_next::FromWireRef<crate::wire::Unavailable> for Unavailable {
7990        #[inline]
7991        fn from_wire_ref(wire: &crate::wire::Unavailable) -> Self {
7992            Self {}
7993        }
7994    }
7995}
7996
7997pub mod wire {
7998
7999    /// The wire type corresponding to [`Availability`].
8000    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
8001    #[repr(transparent)]
8002    pub struct Availability {
8003        pub(crate) value: ::fidl_next::WireU32,
8004    }
8005
8006    unsafe impl ::fidl_next::Wire for Availability {
8007        type Decoded<'de> = Self;
8008
8009        #[inline]
8010        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
8011            // Wire enums have no padding
8012        }
8013    }
8014
8015    impl Availability {
8016        pub const REQUIRED: Availability = Availability { value: ::fidl_next::WireU32(1) };
8017
8018        pub const OPTIONAL: Availability = Availability { value: ::fidl_next::WireU32(2) };
8019
8020        pub const SAME_AS_TARGET: Availability = Availability { value: ::fidl_next::WireU32(3) };
8021
8022        pub const TRANSITIONAL: Availability = Availability { value: ::fidl_next::WireU32(4) };
8023    }
8024
8025    unsafe impl<___D> ::fidl_next::Decode<___D> for Availability
8026    where
8027        ___D: ?Sized,
8028    {
8029        fn decode(
8030            slot: ::fidl_next::Slot<'_, Self>,
8031            _: &mut ___D,
8032            _: (),
8033        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8034            ::fidl_next::munge!(let Self { value } = slot);
8035
8036            match u32::from(*value) {
8037                1 | 2 | 3 | 4 => (),
8038                unknown => {
8039                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
8040                }
8041            }
8042
8043            Ok(())
8044        }
8045    }
8046
8047    impl ::core::convert::From<crate::natural::Availability> for Availability {
8048        fn from(natural: crate::natural::Availability) -> Self {
8049            match natural {
8050                crate::natural::Availability::Required => Availability::REQUIRED,
8051
8052                crate::natural::Availability::Optional => Availability::OPTIONAL,
8053
8054                crate::natural::Availability::SameAsTarget => Availability::SAME_AS_TARGET,
8055
8056                crate::natural::Availability::Transitional => Availability::TRANSITIONAL,
8057            }
8058        }
8059    }
8060
8061    impl ::fidl_next::IntoNatural for Availability {
8062        type Natural = crate::natural::Availability;
8063    }
8064
8065    impl ::fidl_next::Unconstrained for Availability {}
8066
8067    /// The wire type corresponding to [`Unit`].
8068    #[derive(Clone, Debug)]
8069    #[repr(C)]
8070    pub struct Unit {
8071        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
8072    }
8073
8074    static_assertions::const_assert_eq!(std::mem::size_of::<Unit>(), 1);
8075    static_assertions::const_assert_eq!(std::mem::align_of::<Unit>(), 1);
8076
8077    unsafe impl ::fidl_next::Wire for Unit {
8078        type Decoded<'de> = Unit;
8079
8080        #[inline]
8081        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8082            ::fidl_next::munge! {
8083                let Self {
8084
8085                        _empty,
8086
8087
8088                } = &mut *out_;
8089            }
8090        }
8091    }
8092
8093    unsafe impl<___D> ::fidl_next::Decode<___D> for Unit
8094    where
8095        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8096    {
8097        fn decode(
8098            slot_: ::fidl_next::Slot<'_, Self>,
8099            decoder_: &mut ___D,
8100            _: (),
8101        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8102            ::fidl_next::munge! {
8103                let Self {
8104
8105                        mut _empty,
8106
8107
8108                } = slot_;
8109            }
8110
8111            if _empty.as_bytes() != &[0u8] {
8112                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
8113            }
8114
8115            Ok(())
8116        }
8117    }
8118
8119    impl ::fidl_next::IntoNatural for Unit {
8120        type Natural = crate::natural::Unit;
8121    }
8122
8123    impl ::fidl_next::Unconstrained for Unit {}
8124
8125    /// The wire type corresponding to [`Data`].
8126    #[repr(transparent)]
8127    pub struct Data<'de> {
8128        pub(crate) raw: ::fidl_next::RawWireUnion,
8129        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8130    }
8131
8132    impl<'de> Drop for Data<'de> {
8133        fn drop(&mut self) {
8134            match self.raw.ordinal() {
8135                1 => {
8136                    let _ = unsafe {
8137                        self.raw.get().read_unchecked::<::fidl_next::WireVector<'de, u8>>()
8138                    };
8139                }
8140
8141                2 => {
8142                    let _ =
8143                        unsafe { self.raw.get().read_unchecked::<::fidl_next::WireString<'de>>() };
8144                }
8145
8146                3 => {
8147                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireI64>() };
8148                }
8149
8150                4 => {
8151                    let _ = unsafe { self.raw.get().read_unchecked::<::fidl_next::WireU64>() };
8152                }
8153
8154                _ => (),
8155            }
8156        }
8157    }
8158
8159    unsafe impl ::fidl_next::Wire for Data<'static> {
8160        type Decoded<'de> = Data<'de>;
8161
8162        #[inline]
8163        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8164            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8165            ::fidl_next::RawWireUnion::zero_padding(raw);
8166        }
8167    }
8168
8169    pub mod data {
8170        pub enum Ref<'de> {
8171            Bytes(&'de ::fidl_next::WireVector<'de, u8>),
8172
8173            String(&'de ::fidl_next::WireString<'de>),
8174
8175            Int64(&'de ::fidl_next::WireI64),
8176
8177            Uint64(&'de ::fidl_next::WireU64),
8178
8179            UnknownOrdinal_(u64),
8180        }
8181    }
8182
8183    impl<'de> Data<'de> {
8184        pub fn as_ref(&self) -> crate::wire::data::Ref<'_> {
8185            match self.raw.ordinal() {
8186                1 => crate::wire::data::Ref::Bytes(unsafe {
8187                    self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>()
8188                }),
8189
8190                2 => crate::wire::data::Ref::String(unsafe {
8191                    self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>()
8192                }),
8193
8194                3 => crate::wire::data::Ref::Int64(unsafe {
8195                    self.raw.get().deref_unchecked::<::fidl_next::WireI64>()
8196                }),
8197
8198                4 => crate::wire::data::Ref::Uint64(unsafe {
8199                    self.raw.get().deref_unchecked::<::fidl_next::WireU64>()
8200                }),
8201
8202                unknown => crate::wire::data::Ref::UnknownOrdinal_(unknown),
8203            }
8204        }
8205    }
8206
8207    unsafe impl<___D> ::fidl_next::Decode<___D> for Data<'static>
8208    where
8209        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8210        ___D: ::fidl_next::Decoder,
8211    {
8212        fn decode(
8213            mut slot: ::fidl_next::Slot<'_, Self>,
8214            decoder: &mut ___D,
8215            _: (),
8216        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8217            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8218            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
8219                1 => ::fidl_next::RawWireUnion::decode_as::<
8220                    ___D,
8221                    ::fidl_next::WireVector<'static, u8>,
8222                >(raw, decoder, (8192, ()))?,
8223
8224                2 => {
8225                    ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
8226                        raw, decoder, 8192,
8227                    )?
8228                }
8229
8230                3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(
8231                    raw,
8232                    decoder,
8233                    (),
8234                )?,
8235
8236                4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(
8237                    raw,
8238                    decoder,
8239                    (),
8240                )?,
8241
8242                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
8243            }
8244
8245            Ok(())
8246        }
8247    }
8248
8249    impl<'de> ::core::fmt::Debug for Data<'de> {
8250        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8251            match self.raw.ordinal() {
8252                1 => unsafe {
8253                    self.raw.get().deref_unchecked::<::fidl_next::WireVector<'_, u8>>().fmt(f)
8254                },
8255                2 => unsafe {
8256                    self.raw.get().deref_unchecked::<::fidl_next::WireString<'_>>().fmt(f)
8257                },
8258                3 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireI64>().fmt(f) },
8259                4 => unsafe { self.raw.get().deref_unchecked::<::fidl_next::WireU64>().fmt(f) },
8260                _ => unsafe { ::core::hint::unreachable_unchecked() },
8261            }
8262        }
8263    }
8264
8265    impl<'de> ::fidl_next::IntoNatural for Data<'de> {
8266        type Natural = crate::natural::Data;
8267    }
8268
8269    impl ::fidl_next::Unconstrained for Data<'static> {}
8270
8271    /// The wire type corresponding to [`Token`](crate::natural::Token).
8272    pub type Token = ::fidl_next::fuchsia::WireEventPair;
8273
8274    /// The wire type corresponding to [`DictionaryRef`].
8275    #[derive(Debug)]
8276    #[repr(C)]
8277    pub struct DictionaryRef {
8278        pub token: ::fidl_next::fuchsia::WireEventPair,
8279    }
8280
8281    static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryRef>(), 4);
8282    static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryRef>(), 4);
8283
8284    static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryRef, token), 0);
8285
8286    unsafe impl ::fidl_next::Wire for DictionaryRef {
8287        type Decoded<'de> = DictionaryRef;
8288
8289        #[inline]
8290        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8291            ::fidl_next::munge! {
8292                let Self {
8293
8294                    token,
8295
8296                } = &mut *out_;
8297            }
8298
8299            ::fidl_next::Wire::zero_padding(token);
8300        }
8301    }
8302
8303    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRef
8304    where
8305        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8306        ___D: ::fidl_next::fuchsia::HandleDecoder,
8307    {
8308        fn decode(
8309            slot_: ::fidl_next::Slot<'_, Self>,
8310            decoder_: &mut ___D,
8311            _: (),
8312        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8313            ::fidl_next::munge! {
8314                let Self {
8315
8316                    mut token,
8317
8318                } = slot_;
8319            }
8320
8321            let _field = token.as_mut();
8322
8323            ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8324
8325            Ok(())
8326        }
8327    }
8328
8329    impl ::fidl_next::IntoNatural for DictionaryRef {
8330        type Natural = crate::natural::DictionaryRef;
8331    }
8332
8333    impl ::fidl_next::Unconstrained for DictionaryRef {}
8334
8335    /// The wire type corresponding to [`Connector`].
8336    #[derive(Debug)]
8337    #[repr(C)]
8338    pub struct Connector {
8339        pub token: ::fidl_next::fuchsia::WireEventPair,
8340    }
8341
8342    static_assertions::const_assert_eq!(std::mem::size_of::<Connector>(), 4);
8343    static_assertions::const_assert_eq!(std::mem::align_of::<Connector>(), 4);
8344
8345    static_assertions::const_assert_eq!(std::mem::offset_of!(Connector, token), 0);
8346
8347    unsafe impl ::fidl_next::Wire for Connector {
8348        type Decoded<'de> = Connector;
8349
8350        #[inline]
8351        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8352            ::fidl_next::munge! {
8353                let Self {
8354
8355                    token,
8356
8357                } = &mut *out_;
8358            }
8359
8360            ::fidl_next::Wire::zero_padding(token);
8361        }
8362    }
8363
8364    unsafe impl<___D> ::fidl_next::Decode<___D> for Connector
8365    where
8366        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8367        ___D: ::fidl_next::fuchsia::HandleDecoder,
8368    {
8369        fn decode(
8370            slot_: ::fidl_next::Slot<'_, Self>,
8371            decoder_: &mut ___D,
8372            _: (),
8373        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8374            ::fidl_next::munge! {
8375                let Self {
8376
8377                    mut token,
8378
8379                } = slot_;
8380            }
8381
8382            let _field = token.as_mut();
8383
8384            ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8385
8386            Ok(())
8387        }
8388    }
8389
8390    impl ::fidl_next::IntoNatural for Connector {
8391        type Natural = crate::natural::Connector;
8392    }
8393
8394    impl ::fidl_next::Unconstrained for Connector {}
8395
8396    /// The wire type corresponding to [`DirConnector`].
8397    #[derive(Debug)]
8398    #[repr(C)]
8399    pub struct DirConnector {
8400        pub token: ::fidl_next::fuchsia::WireEventPair,
8401    }
8402
8403    static_assertions::const_assert_eq!(std::mem::size_of::<DirConnector>(), 4);
8404    static_assertions::const_assert_eq!(std::mem::align_of::<DirConnector>(), 4);
8405
8406    static_assertions::const_assert_eq!(std::mem::offset_of!(DirConnector, token), 0);
8407
8408    unsafe impl ::fidl_next::Wire for DirConnector {
8409        type Decoded<'de> = DirConnector;
8410
8411        #[inline]
8412        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8413            ::fidl_next::munge! {
8414                let Self {
8415
8416                    token,
8417
8418                } = &mut *out_;
8419            }
8420
8421            ::fidl_next::Wire::zero_padding(token);
8422        }
8423    }
8424
8425    unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnector
8426    where
8427        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8428        ___D: ::fidl_next::fuchsia::HandleDecoder,
8429    {
8430        fn decode(
8431            slot_: ::fidl_next::Slot<'_, Self>,
8432            decoder_: &mut ___D,
8433            _: (),
8434        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8435            ::fidl_next::munge! {
8436                let Self {
8437
8438                    mut token,
8439
8440                } = slot_;
8441            }
8442
8443            let _field = token.as_mut();
8444
8445            ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8446
8447            Ok(())
8448        }
8449    }
8450
8451    impl ::fidl_next::IntoNatural for DirConnector {
8452        type Natural = crate::natural::DirConnector;
8453    }
8454
8455    impl ::fidl_next::Unconstrained for DirConnector {}
8456
8457    /// The wire type corresponding to [`DirEntry`].
8458    #[derive(Debug)]
8459    #[repr(C)]
8460    pub struct DirEntry {
8461        pub token: ::fidl_next::fuchsia::WireEventPair,
8462    }
8463
8464    static_assertions::const_assert_eq!(std::mem::size_of::<DirEntry>(), 4);
8465    static_assertions::const_assert_eq!(std::mem::align_of::<DirEntry>(), 4);
8466
8467    static_assertions::const_assert_eq!(std::mem::offset_of!(DirEntry, token), 0);
8468
8469    unsafe impl ::fidl_next::Wire for DirEntry {
8470        type Decoded<'de> = DirEntry;
8471
8472        #[inline]
8473        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8474            ::fidl_next::munge! {
8475                let Self {
8476
8477                    token,
8478
8479                } = &mut *out_;
8480            }
8481
8482            ::fidl_next::Wire::zero_padding(token);
8483        }
8484    }
8485
8486    unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntry
8487    where
8488        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8489        ___D: ::fidl_next::fuchsia::HandleDecoder,
8490    {
8491        fn decode(
8492            slot_: ::fidl_next::Slot<'_, Self>,
8493            decoder_: &mut ___D,
8494            _: (),
8495        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8496            ::fidl_next::munge! {
8497                let Self {
8498
8499                    mut token,
8500
8501                } = slot_;
8502            }
8503
8504            let _field = token.as_mut();
8505
8506            ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
8507
8508            Ok(())
8509        }
8510    }
8511
8512    impl ::fidl_next::IntoNatural for DirEntry {
8513        type Natural = crate::natural::DirEntry;
8514    }
8515
8516    impl ::fidl_next::Unconstrained for DirEntry {}
8517
8518    /// The wire type corresponding to [`Capability`].
8519    #[repr(transparent)]
8520    pub struct Capability<'de> {
8521        pub(crate) raw: ::fidl_next::RawWireUnion,
8522        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
8523    }
8524
8525    impl<'de> Drop for Capability<'de> {
8526        fn drop(&mut self) {
8527            match self.raw.ordinal() {
8528                1 => {
8529                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
8530                }
8531
8532                2 => {
8533                    let _ = unsafe {
8534                        self.raw.get().read_unchecked::<::fidl_next::fuchsia::WireHandle>()
8535                    };
8536                }
8537
8538                3 => {
8539                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
8540                }
8541
8542                4 => {
8543                    let _ =
8544                        unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
8545                }
8546
8547                5 => {
8548                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
8549                }
8550
8551                6 => {
8552                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
8553                }
8554
8555                7 => {
8556                    let _ = unsafe {
8557                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8558                            ::fidl_next_fuchsia_io::Directory,
8559                            ::fidl_next::fuchsia::WireChannel,
8560                        >>()
8561                    };
8562                }
8563
8564                8 => {
8565                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
8566                }
8567
8568                9 => {
8569                    let _ = unsafe {
8570                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8571                            crate::ConnectorRouter,
8572                            ::fidl_next::fuchsia::WireChannel,
8573                        >>()
8574                    };
8575                }
8576
8577                10 => {
8578                    let _ = unsafe {
8579                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8580                            crate::DictionaryRouter,
8581                            ::fidl_next::fuchsia::WireChannel,
8582                        >>()
8583                    };
8584                }
8585
8586                11 => {
8587                    let _ = unsafe {
8588                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8589                            crate::DirEntryRouter,
8590                            ::fidl_next::fuchsia::WireChannel,
8591                        >>()
8592                    };
8593                }
8594
8595                12 => {
8596                    let _ = unsafe {
8597                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8598                            crate::DataRouter,
8599                            ::fidl_next::fuchsia::WireChannel,
8600                        >>()
8601                    };
8602                }
8603
8604                13 => {
8605                    let _ = unsafe {
8606                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
8607                            crate::DirConnectorRouter,
8608                            ::fidl_next::fuchsia::WireChannel,
8609                        >>()
8610                    };
8611                }
8612
8613                _ => (),
8614            }
8615        }
8616    }
8617
8618    unsafe impl ::fidl_next::Wire for Capability<'static> {
8619        type Decoded<'de> = Capability<'de>;
8620
8621        #[inline]
8622        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
8623            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
8624            ::fidl_next::RawWireUnion::zero_padding(raw);
8625        }
8626    }
8627
8628    pub mod capability {
8629        pub enum Ref<'de> {
8630            Unit(&'de crate::wire::Unit),
8631
8632            Handle(&'de ::fidl_next::fuchsia::WireHandle),
8633
8634            Data(&'de crate::wire::Data<'de>),
8635
8636            Dictionary(&'de crate::wire::DictionaryRef),
8637
8638            Connector(&'de crate::wire::Connector),
8639
8640            DirConnector(&'de crate::wire::DirConnector),
8641
8642            Directory(
8643                &'de ::fidl_next::ClientEnd<
8644                    ::fidl_next_fuchsia_io::Directory,
8645                    ::fidl_next::fuchsia::WireChannel,
8646                >,
8647            ),
8648
8649            DirEntry(&'de crate::wire::DirEntry),
8650
8651            ConnectorRouter(
8652                &'de ::fidl_next::ClientEnd<
8653                    crate::ConnectorRouter,
8654                    ::fidl_next::fuchsia::WireChannel,
8655                >,
8656            ),
8657
8658            DictionaryRouter(
8659                &'de ::fidl_next::ClientEnd<
8660                    crate::DictionaryRouter,
8661                    ::fidl_next::fuchsia::WireChannel,
8662                >,
8663            ),
8664
8665            DirEntryRouter(
8666                &'de ::fidl_next::ClientEnd<
8667                    crate::DirEntryRouter,
8668                    ::fidl_next::fuchsia::WireChannel,
8669                >,
8670            ),
8671
8672            DataRouter(
8673                &'de ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
8674            ),
8675
8676            DirConnectorRouter(
8677                &'de ::fidl_next::ClientEnd<
8678                    crate::DirConnectorRouter,
8679                    ::fidl_next::fuchsia::WireChannel,
8680                >,
8681            ),
8682
8683            UnknownOrdinal_(u64),
8684        }
8685    }
8686
8687    impl<'de> Capability<'de> {
8688        pub fn as_ref(&self) -> crate::wire::capability::Ref<'_> {
8689            match self.raw.ordinal() {
8690                1 => crate::wire::capability::Ref::Unit(unsafe {
8691                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
8692                }),
8693
8694                2 => crate::wire::capability::Ref::Handle(unsafe {
8695                    self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>()
8696                }),
8697
8698                3 => crate::wire::capability::Ref::Data(unsafe {
8699                    self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
8700                }),
8701
8702                4 => crate::wire::capability::Ref::Dictionary(unsafe {
8703                    self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
8704                }),
8705
8706                5 => crate::wire::capability::Ref::Connector(unsafe {
8707                    self.raw.get().deref_unchecked::<crate::wire::Connector>()
8708                }),
8709
8710                6 => crate::wire::capability::Ref::DirConnector(unsafe {
8711                    self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
8712                }),
8713
8714                7 => crate::wire::capability::Ref::Directory(unsafe {
8715                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8716                        ::fidl_next_fuchsia_io::Directory,
8717                        ::fidl_next::fuchsia::WireChannel,
8718                    >>()
8719                }),
8720
8721                8 => crate::wire::capability::Ref::DirEntry(unsafe {
8722                    self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
8723                }),
8724
8725                9 => crate::wire::capability::Ref::ConnectorRouter(unsafe {
8726                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8727                        crate::ConnectorRouter,
8728                        ::fidl_next::fuchsia::WireChannel,
8729                    >>()
8730                }),
8731
8732                10 => crate::wire::capability::Ref::DictionaryRouter(unsafe {
8733                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8734                        crate::DictionaryRouter,
8735                        ::fidl_next::fuchsia::WireChannel,
8736                    >>()
8737                }),
8738
8739                11 => crate::wire::capability::Ref::DirEntryRouter(unsafe {
8740                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8741                        crate::DirEntryRouter,
8742                        ::fidl_next::fuchsia::WireChannel,
8743                    >>()
8744                }),
8745
8746                12 => crate::wire::capability::Ref::DataRouter(unsafe {
8747                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>>()
8748                }),
8749
8750                13 => crate::wire::capability::Ref::DirConnectorRouter(unsafe {
8751                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
8752                        crate::DirConnectorRouter,
8753                        ::fidl_next::fuchsia::WireChannel,
8754                    >>()
8755                }),
8756
8757                unknown => crate::wire::capability::Ref::UnknownOrdinal_(unknown),
8758            }
8759        }
8760    }
8761
8762    unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
8763    where
8764        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8765        ___D: ::fidl_next::Decoder,
8766        ___D: ::fidl_next::fuchsia::HandleDecoder,
8767    {
8768        fn decode(
8769            mut slot: ::fidl_next::Slot<'_, Self>,
8770            decoder: &mut ___D,
8771            _: (),
8772        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
8773            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
8774            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
8775                1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
8776                    raw,
8777                    decoder,
8778                    (),
8779                )?,
8780
8781                2 => {
8782                    ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
8783                        raw,
8784                        decoder,
8785                        (),
8786                    )?
8787                }
8788
8789                3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
8790                    raw,
8791                    decoder,
8792                    (),
8793                )?,
8794
8795                4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
8796                    raw,
8797                    decoder,
8798                    (),
8799                )?,
8800
8801                5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
8802                    raw,
8803                    decoder,
8804                    (),
8805                )?,
8806
8807                6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
8808                    raw,
8809                    decoder,
8810                    (),
8811                )?,
8812
8813                7 => ::fidl_next::RawWireUnion::decode_as::<
8814                    ___D,
8815                    ::fidl_next::ClientEnd<
8816                        ::fidl_next_fuchsia_io::Directory,
8817                        ::fidl_next::fuchsia::WireChannel,
8818                    >,
8819                >(raw, decoder, ())?,
8820
8821                8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
8822                    raw,
8823                    decoder,
8824                    (),
8825                )?,
8826
8827                9 => ::fidl_next::RawWireUnion::decode_as::<
8828                    ___D,
8829                    ::fidl_next::ClientEnd<
8830                        crate::ConnectorRouter,
8831                        ::fidl_next::fuchsia::WireChannel,
8832                    >,
8833                >(raw, decoder, ())?,
8834
8835                10 => ::fidl_next::RawWireUnion::decode_as::<
8836                    ___D,
8837                    ::fidl_next::ClientEnd<
8838                        crate::DictionaryRouter,
8839                        ::fidl_next::fuchsia::WireChannel,
8840                    >,
8841                >(raw, decoder, ())?,
8842
8843                11 => ::fidl_next::RawWireUnion::decode_as::<
8844                    ___D,
8845                    ::fidl_next::ClientEnd<
8846                        crate::DirEntryRouter,
8847                        ::fidl_next::fuchsia::WireChannel,
8848                    >,
8849                >(raw, decoder, ())?,
8850
8851                12 => ::fidl_next::RawWireUnion::decode_as::<
8852                    ___D,
8853                    ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
8854                >(raw, decoder, ())?,
8855
8856                13 => ::fidl_next::RawWireUnion::decode_as::<
8857                    ___D,
8858                    ::fidl_next::ClientEnd<
8859                        crate::DirConnectorRouter,
8860                        ::fidl_next::fuchsia::WireChannel,
8861                    >,
8862                >(raw, decoder, ())?,
8863
8864                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
8865            }
8866
8867            Ok(())
8868        }
8869    }
8870
8871    impl<'de> ::core::fmt::Debug for Capability<'de> {
8872        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
8873            match self.raw.ordinal() {
8874                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
8875                2 => unsafe {
8876                    self.raw.get().deref_unchecked::<::fidl_next::fuchsia::WireHandle>().fmt(f)
8877                },
8878                3 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
8879                4 => unsafe {
8880                    self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
8881                },
8882                5 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
8883                6 => unsafe {
8884                    self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
8885                },
8886                7 => unsafe {
8887                    self.raw
8888                        .get()
8889                        .deref_unchecked::<::fidl_next::ClientEnd<
8890                            ::fidl_next_fuchsia_io::Directory,
8891                            ::fidl_next::fuchsia::WireChannel,
8892                        >>()
8893                        .fmt(f)
8894                },
8895                8 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
8896                9 => unsafe {
8897                    self.raw
8898                        .get()
8899                        .deref_unchecked::<::fidl_next::ClientEnd<
8900                            crate::ConnectorRouter,
8901                            ::fidl_next::fuchsia::WireChannel,
8902                        >>()
8903                        .fmt(f)
8904                },
8905                10 => unsafe {
8906                    self.raw
8907                        .get()
8908                        .deref_unchecked::<::fidl_next::ClientEnd<
8909                            crate::DictionaryRouter,
8910                            ::fidl_next::fuchsia::WireChannel,
8911                        >>()
8912                        .fmt(f)
8913                },
8914                11 => unsafe {
8915                    self.raw
8916                        .get()
8917                        .deref_unchecked::<::fidl_next::ClientEnd<
8918                            crate::DirEntryRouter,
8919                            ::fidl_next::fuchsia::WireChannel,
8920                        >>()
8921                        .fmt(f)
8922                },
8923                12 => unsafe {
8924                    self.raw.get().deref_unchecked::<
8925                            ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>
8926                        >().fmt(f)
8927                },
8928                13 => unsafe {
8929                    self.raw
8930                        .get()
8931                        .deref_unchecked::<::fidl_next::ClientEnd<
8932                            crate::DirConnectorRouter,
8933                            ::fidl_next::fuchsia::WireChannel,
8934                        >>()
8935                        .fmt(f)
8936                },
8937                _ => unsafe { ::core::hint::unreachable_unchecked() },
8938            }
8939        }
8940    }
8941
8942    impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
8943        type Natural = crate::natural::Capability;
8944    }
8945
8946    impl ::fidl_next::Unconstrained for Capability<'static> {}
8947
8948    /// The wire type corresponding to [`CapabilityId`](crate::natural::CapabilityId).
8949    pub type CapabilityId = ::fidl_next::WireU64;
8950
8951    /// The wire type corresponding to [`NewCapabilityId`](crate::natural::NewCapabilityId).
8952    pub type NewCapabilityId = ::fidl_next::WireU64;
8953
8954    /// The wire type corresponding to [`CapabilityStoreDuplicateRequest`].
8955    #[derive(Clone, Debug)]
8956    #[repr(C)]
8957    pub struct CapabilityStoreDuplicateRequest {
8958        pub id: ::fidl_next::WireU64,
8959
8960        pub dest_id: ::fidl_next::WireU64,
8961    }
8962
8963    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateRequest>(), 16);
8964    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDuplicateRequest>(), 8);
8965
8966    static_assertions::const_assert_eq!(
8967        std::mem::offset_of!(CapabilityStoreDuplicateRequest, id),
8968        0
8969    );
8970
8971    static_assertions::const_assert_eq!(
8972        std::mem::offset_of!(CapabilityStoreDuplicateRequest, dest_id),
8973        8
8974    );
8975
8976    unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateRequest {
8977        type Decoded<'de> = CapabilityStoreDuplicateRequest;
8978
8979        #[inline]
8980        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
8981            ::fidl_next::munge! {
8982                let Self {
8983
8984                    id,
8985                    dest_id,
8986
8987                } = &mut *out_;
8988            }
8989
8990            ::fidl_next::Wire::zero_padding(id);
8991
8992            ::fidl_next::Wire::zero_padding(dest_id);
8993        }
8994    }
8995
8996    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateRequest
8997    where
8998        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
8999    {
9000        fn decode(
9001            slot_: ::fidl_next::Slot<'_, Self>,
9002            decoder_: &mut ___D,
9003            _: (),
9004        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9005            ::fidl_next::munge! {
9006                let Self {
9007
9008                    mut id,
9009                    mut dest_id,
9010
9011                } = slot_;
9012            }
9013
9014            let _field = id.as_mut();
9015
9016            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9017
9018            let _field = dest_id.as_mut();
9019
9020            ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
9021
9022            Ok(())
9023        }
9024    }
9025
9026    impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateRequest {
9027        type Natural = crate::natural::CapabilityStoreDuplicateRequest;
9028    }
9029
9030    impl ::fidl_next::Unconstrained for CapabilityStoreDuplicateRequest {}
9031
9032    /// The wire type corresponding to [`CapabilityStoreDuplicateResponse`].
9033    #[derive(Clone, Debug)]
9034    #[repr(C)]
9035    pub struct CapabilityStoreDuplicateResponse {
9036        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9037    }
9038
9039    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDuplicateResponse>(), 1);
9040    static_assertions::const_assert_eq!(
9041        std::mem::align_of::<CapabilityStoreDuplicateResponse>(),
9042        1
9043    );
9044
9045    unsafe impl ::fidl_next::Wire for CapabilityStoreDuplicateResponse {
9046        type Decoded<'de> = CapabilityStoreDuplicateResponse;
9047
9048        #[inline]
9049        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9050            ::fidl_next::munge! {
9051                let Self {
9052
9053                        _empty,
9054
9055
9056                } = &mut *out_;
9057            }
9058        }
9059    }
9060
9061    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDuplicateResponse
9062    where
9063        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9064    {
9065        fn decode(
9066            slot_: ::fidl_next::Slot<'_, Self>,
9067            decoder_: &mut ___D,
9068            _: (),
9069        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9070            ::fidl_next::munge! {
9071                let Self {
9072
9073                        mut _empty,
9074
9075
9076                } = slot_;
9077            }
9078
9079            if _empty.as_bytes() != &[0u8] {
9080                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9081            }
9082
9083            Ok(())
9084        }
9085    }
9086
9087    impl ::fidl_next::IntoNatural for CapabilityStoreDuplicateResponse {
9088        type Natural = crate::natural::CapabilityStoreDuplicateResponse;
9089    }
9090
9091    impl ::fidl_next::Unconstrained for CapabilityStoreDuplicateResponse {}
9092
9093    /// The wire type corresponding to [`CapabilityStoreError`].
9094    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
9095    #[repr(transparent)]
9096    pub struct CapabilityStoreError {
9097        pub(crate) value: ::fidl_next::WireU32,
9098    }
9099
9100    unsafe impl ::fidl_next::Wire for CapabilityStoreError {
9101        type Decoded<'de> = Self;
9102
9103        #[inline]
9104        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
9105            // Wire enums have no padding
9106        }
9107    }
9108
9109    impl CapabilityStoreError {
9110        pub const ID_NOT_FOUND: CapabilityStoreError =
9111            CapabilityStoreError { value: ::fidl_next::WireU32(1) };
9112
9113        pub const ID_ALREADY_EXISTS: CapabilityStoreError =
9114            CapabilityStoreError { value: ::fidl_next::WireU32(2) };
9115
9116        pub const BAD_CAPABILITY: CapabilityStoreError =
9117            CapabilityStoreError { value: ::fidl_next::WireU32(3) };
9118
9119        pub const WRONG_TYPE: CapabilityStoreError =
9120            CapabilityStoreError { value: ::fidl_next::WireU32(4) };
9121
9122        pub const NOT_DUPLICATABLE: CapabilityStoreError =
9123            CapabilityStoreError { value: ::fidl_next::WireU32(5) };
9124
9125        pub const ITEM_NOT_FOUND: CapabilityStoreError =
9126            CapabilityStoreError { value: ::fidl_next::WireU32(6) };
9127
9128        pub const ITEM_ALREADY_EXISTS: CapabilityStoreError =
9129            CapabilityStoreError { value: ::fidl_next::WireU32(7) };
9130
9131        pub const INVALID_KEY: CapabilityStoreError =
9132            CapabilityStoreError { value: ::fidl_next::WireU32(8) };
9133
9134        pub const INVALID_ARGS: CapabilityStoreError =
9135            CapabilityStoreError { value: ::fidl_next::WireU32(9) };
9136    }
9137
9138    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreError
9139    where
9140        ___D: ?Sized,
9141    {
9142        fn decode(
9143            slot: ::fidl_next::Slot<'_, Self>,
9144            _: &mut ___D,
9145            _: (),
9146        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9147            Ok(())
9148        }
9149    }
9150
9151    impl ::core::convert::From<crate::natural::CapabilityStoreError> for CapabilityStoreError {
9152        fn from(natural: crate::natural::CapabilityStoreError) -> Self {
9153            match natural {
9154                crate::natural::CapabilityStoreError::IdNotFound => {
9155                    CapabilityStoreError::ID_NOT_FOUND
9156                }
9157
9158                crate::natural::CapabilityStoreError::IdAlreadyExists => {
9159                    CapabilityStoreError::ID_ALREADY_EXISTS
9160                }
9161
9162                crate::natural::CapabilityStoreError::BadCapability => {
9163                    CapabilityStoreError::BAD_CAPABILITY
9164                }
9165
9166                crate::natural::CapabilityStoreError::WrongType => CapabilityStoreError::WRONG_TYPE,
9167
9168                crate::natural::CapabilityStoreError::NotDuplicatable => {
9169                    CapabilityStoreError::NOT_DUPLICATABLE
9170                }
9171
9172                crate::natural::CapabilityStoreError::ItemNotFound => {
9173                    CapabilityStoreError::ITEM_NOT_FOUND
9174                }
9175
9176                crate::natural::CapabilityStoreError::ItemAlreadyExists => {
9177                    CapabilityStoreError::ITEM_ALREADY_EXISTS
9178                }
9179
9180                crate::natural::CapabilityStoreError::InvalidKey => {
9181                    CapabilityStoreError::INVALID_KEY
9182                }
9183
9184                crate::natural::CapabilityStoreError::InvalidArgs => {
9185                    CapabilityStoreError::INVALID_ARGS
9186                }
9187
9188                crate::natural::CapabilityStoreError::UnknownOrdinal_(value) => {
9189                    CapabilityStoreError { value: ::fidl_next::WireU32::from(value) }
9190                }
9191            }
9192        }
9193    }
9194
9195    impl ::fidl_next::IntoNatural for CapabilityStoreError {
9196        type Natural = crate::natural::CapabilityStoreError;
9197    }
9198
9199    impl ::fidl_next::Unconstrained for CapabilityStoreError {}
9200
9201    /// The wire type corresponding to [`CapabilityStoreDropRequest`].
9202    #[derive(Clone, Debug)]
9203    #[repr(C)]
9204    pub struct CapabilityStoreDropRequest {
9205        pub id: ::fidl_next::WireU64,
9206    }
9207
9208    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropRequest>(), 8);
9209    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropRequest>(), 8);
9210
9211    static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreDropRequest, id), 0);
9212
9213    unsafe impl ::fidl_next::Wire for CapabilityStoreDropRequest {
9214        type Decoded<'de> = CapabilityStoreDropRequest;
9215
9216        #[inline]
9217        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9218            ::fidl_next::munge! {
9219                let Self {
9220
9221                    id,
9222
9223                } = &mut *out_;
9224            }
9225
9226            ::fidl_next::Wire::zero_padding(id);
9227        }
9228    }
9229
9230    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropRequest
9231    where
9232        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9233    {
9234        fn decode(
9235            slot_: ::fidl_next::Slot<'_, Self>,
9236            decoder_: &mut ___D,
9237            _: (),
9238        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9239            ::fidl_next::munge! {
9240                let Self {
9241
9242                    mut id,
9243
9244                } = slot_;
9245            }
9246
9247            let _field = id.as_mut();
9248
9249            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9250
9251            Ok(())
9252        }
9253    }
9254
9255    impl ::fidl_next::IntoNatural for CapabilityStoreDropRequest {
9256        type Natural = crate::natural::CapabilityStoreDropRequest;
9257    }
9258
9259    impl ::fidl_next::Unconstrained for CapabilityStoreDropRequest {}
9260
9261    /// The wire type corresponding to [`CapabilityStoreDropResponse`].
9262    #[derive(Clone, Debug)]
9263    #[repr(C)]
9264    pub struct CapabilityStoreDropResponse {
9265        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9266    }
9267
9268    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreDropResponse>(), 1);
9269    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreDropResponse>(), 1);
9270
9271    unsafe impl ::fidl_next::Wire for CapabilityStoreDropResponse {
9272        type Decoded<'de> = CapabilityStoreDropResponse;
9273
9274        #[inline]
9275        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9276            ::fidl_next::munge! {
9277                let Self {
9278
9279                        _empty,
9280
9281
9282                } = &mut *out_;
9283            }
9284        }
9285    }
9286
9287    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDropResponse
9288    where
9289        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9290    {
9291        fn decode(
9292            slot_: ::fidl_next::Slot<'_, Self>,
9293            decoder_: &mut ___D,
9294            _: (),
9295        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9296            ::fidl_next::munge! {
9297                let Self {
9298
9299                        mut _empty,
9300
9301
9302                } = slot_;
9303            }
9304
9305            if _empty.as_bytes() != &[0u8] {
9306                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9307            }
9308
9309            Ok(())
9310        }
9311    }
9312
9313    impl ::fidl_next::IntoNatural for CapabilityStoreDropResponse {
9314        type Natural = crate::natural::CapabilityStoreDropResponse;
9315    }
9316
9317    impl ::fidl_next::Unconstrained for CapabilityStoreDropResponse {}
9318
9319    /// The wire type corresponding to [`CapabilityStoreExportRequest`].
9320    #[derive(Clone, Debug)]
9321    #[repr(C)]
9322    pub struct CapabilityStoreExportRequest {
9323        pub id: ::fidl_next::WireU64,
9324    }
9325
9326    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreExportRequest>(), 8);
9327    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreExportRequest>(), 8);
9328
9329    static_assertions::const_assert_eq!(std::mem::offset_of!(CapabilityStoreExportRequest, id), 0);
9330
9331    unsafe impl ::fidl_next::Wire for CapabilityStoreExportRequest {
9332        type Decoded<'de> = CapabilityStoreExportRequest;
9333
9334        #[inline]
9335        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9336            ::fidl_next::munge! {
9337                let Self {
9338
9339                    id,
9340
9341                } = &mut *out_;
9342            }
9343
9344            ::fidl_next::Wire::zero_padding(id);
9345        }
9346    }
9347
9348    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportRequest
9349    where
9350        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9351    {
9352        fn decode(
9353            slot_: ::fidl_next::Slot<'_, Self>,
9354            decoder_: &mut ___D,
9355            _: (),
9356        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9357            ::fidl_next::munge! {
9358                let Self {
9359
9360                    mut id,
9361
9362                } = slot_;
9363            }
9364
9365            let _field = id.as_mut();
9366
9367            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9368
9369            Ok(())
9370        }
9371    }
9372
9373    impl ::fidl_next::IntoNatural for CapabilityStoreExportRequest {
9374        type Natural = crate::natural::CapabilityStoreExportRequest;
9375    }
9376
9377    impl ::fidl_next::Unconstrained for CapabilityStoreExportRequest {}
9378
9379    /// The wire type corresponding to [`CapabilityStoreImportResponse`].
9380    #[derive(Clone, Debug)]
9381    #[repr(C)]
9382    pub struct CapabilityStoreImportResponse {
9383        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9384    }
9385
9386    static_assertions::const_assert_eq!(std::mem::size_of::<CapabilityStoreImportResponse>(), 1);
9387    static_assertions::const_assert_eq!(std::mem::align_of::<CapabilityStoreImportResponse>(), 1);
9388
9389    unsafe impl ::fidl_next::Wire for CapabilityStoreImportResponse {
9390        type Decoded<'de> = CapabilityStoreImportResponse;
9391
9392        #[inline]
9393        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9394            ::fidl_next::munge! {
9395                let Self {
9396
9397                        _empty,
9398
9399
9400                } = &mut *out_;
9401            }
9402        }
9403    }
9404
9405    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportResponse
9406    where
9407        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9408    {
9409        fn decode(
9410            slot_: ::fidl_next::Slot<'_, Self>,
9411            decoder_: &mut ___D,
9412            _: (),
9413        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9414            ::fidl_next::munge! {
9415                let Self {
9416
9417                        mut _empty,
9418
9419
9420                } = slot_;
9421            }
9422
9423            if _empty.as_bytes() != &[0u8] {
9424                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9425            }
9426
9427            Ok(())
9428        }
9429    }
9430
9431    impl ::fidl_next::IntoNatural for CapabilityStoreImportResponse {
9432        type Natural = crate::natural::CapabilityStoreImportResponse;
9433    }
9434
9435    impl ::fidl_next::Unconstrained for CapabilityStoreImportResponse {}
9436
9437    /// The wire type corresponding to [`CapabilityStoreConnectorCreateRequest`].
9438    #[derive(Debug)]
9439    #[repr(C)]
9440    pub struct CapabilityStoreConnectorCreateRequest {
9441        pub id: ::fidl_next::WireU64,
9442
9443        pub receiver: ::fidl_next::ClientEnd<crate::Receiver, ::fidl_next::fuchsia::WireChannel>,
9444    }
9445
9446    static_assertions::const_assert_eq!(
9447        std::mem::size_of::<CapabilityStoreConnectorCreateRequest>(),
9448        16
9449    );
9450    static_assertions::const_assert_eq!(
9451        std::mem::align_of::<CapabilityStoreConnectorCreateRequest>(),
9452        8
9453    );
9454
9455    static_assertions::const_assert_eq!(
9456        std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, id),
9457        0
9458    );
9459
9460    static_assertions::const_assert_eq!(
9461        std::mem::offset_of!(CapabilityStoreConnectorCreateRequest, receiver),
9462        8
9463    );
9464
9465    unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateRequest {
9466        type Decoded<'de> = CapabilityStoreConnectorCreateRequest;
9467
9468        #[inline]
9469        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9470            ::fidl_next::munge! {
9471                let Self {
9472
9473                    id,
9474                    receiver,
9475
9476                } = &mut *out_;
9477            }
9478
9479            ::fidl_next::Wire::zero_padding(id);
9480
9481            ::fidl_next::Wire::zero_padding(receiver);
9482
9483            unsafe {
9484                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
9485            }
9486        }
9487    }
9488
9489    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateRequest
9490    where
9491        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9492        ___D: ::fidl_next::fuchsia::HandleDecoder,
9493    {
9494        fn decode(
9495            slot_: ::fidl_next::Slot<'_, Self>,
9496            decoder_: &mut ___D,
9497            _: (),
9498        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9499            if slot_.as_bytes()[12..16] != [0u8; 4] {
9500                return Err(::fidl_next::DecodeError::InvalidPadding);
9501            }
9502
9503            ::fidl_next::munge! {
9504                let Self {
9505
9506                    mut id,
9507                    mut receiver,
9508
9509                } = slot_;
9510            }
9511
9512            let _field = id.as_mut();
9513
9514            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9515
9516            let _field = receiver.as_mut();
9517
9518            ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
9519
9520            Ok(())
9521        }
9522    }
9523
9524    impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateRequest {
9525        type Natural = crate::natural::CapabilityStoreConnectorCreateRequest;
9526    }
9527
9528    impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateRequest {}
9529
9530    /// The wire type corresponding to [`CapabilityStoreConnectorCreateResponse`].
9531    #[derive(Clone, Debug)]
9532    #[repr(C)]
9533    pub struct CapabilityStoreConnectorCreateResponse {
9534        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9535    }
9536
9537    static_assertions::const_assert_eq!(
9538        std::mem::size_of::<CapabilityStoreConnectorCreateResponse>(),
9539        1
9540    );
9541    static_assertions::const_assert_eq!(
9542        std::mem::align_of::<CapabilityStoreConnectorCreateResponse>(),
9543        1
9544    );
9545
9546    unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorCreateResponse {
9547        type Decoded<'de> = CapabilityStoreConnectorCreateResponse;
9548
9549        #[inline]
9550        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9551            ::fidl_next::munge! {
9552                let Self {
9553
9554                        _empty,
9555
9556
9557                } = &mut *out_;
9558            }
9559        }
9560    }
9561
9562    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorCreateResponse
9563    where
9564        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9565    {
9566        fn decode(
9567            slot_: ::fidl_next::Slot<'_, Self>,
9568            decoder_: &mut ___D,
9569            _: (),
9570        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9571            ::fidl_next::munge! {
9572                let Self {
9573
9574                        mut _empty,
9575
9576
9577                } = slot_;
9578            }
9579
9580            if _empty.as_bytes() != &[0u8] {
9581                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9582            }
9583
9584            Ok(())
9585        }
9586    }
9587
9588    impl ::fidl_next::IntoNatural for CapabilityStoreConnectorCreateResponse {
9589        type Natural = crate::natural::CapabilityStoreConnectorCreateResponse;
9590    }
9591
9592    impl ::fidl_next::Unconstrained for CapabilityStoreConnectorCreateResponse {}
9593
9594    /// The wire type corresponding to [`CapabilityStoreConnectorOpenRequest`].
9595    #[derive(Debug)]
9596    #[repr(C)]
9597    pub struct CapabilityStoreConnectorOpenRequest {
9598        pub id: ::fidl_next::WireU64,
9599
9600        pub server_end: ::fidl_next::fuchsia::WireChannel,
9601    }
9602
9603    static_assertions::const_assert_eq!(
9604        std::mem::size_of::<CapabilityStoreConnectorOpenRequest>(),
9605        16
9606    );
9607    static_assertions::const_assert_eq!(
9608        std::mem::align_of::<CapabilityStoreConnectorOpenRequest>(),
9609        8
9610    );
9611
9612    static_assertions::const_assert_eq!(
9613        std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, id),
9614        0
9615    );
9616
9617    static_assertions::const_assert_eq!(
9618        std::mem::offset_of!(CapabilityStoreConnectorOpenRequest, server_end),
9619        8
9620    );
9621
9622    unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenRequest {
9623        type Decoded<'de> = CapabilityStoreConnectorOpenRequest;
9624
9625        #[inline]
9626        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9627            ::fidl_next::munge! {
9628                let Self {
9629
9630                    id,
9631                    server_end,
9632
9633                } = &mut *out_;
9634            }
9635
9636            ::fidl_next::Wire::zero_padding(id);
9637
9638            ::fidl_next::Wire::zero_padding(server_end);
9639
9640            unsafe {
9641                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
9642            }
9643        }
9644    }
9645
9646    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenRequest
9647    where
9648        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9649        ___D: ::fidl_next::fuchsia::HandleDecoder,
9650    {
9651        fn decode(
9652            slot_: ::fidl_next::Slot<'_, Self>,
9653            decoder_: &mut ___D,
9654            _: (),
9655        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9656            if slot_.as_bytes()[12..16] != [0u8; 4] {
9657                return Err(::fidl_next::DecodeError::InvalidPadding);
9658            }
9659
9660            ::fidl_next::munge! {
9661                let Self {
9662
9663                    mut id,
9664                    mut server_end,
9665
9666                } = slot_;
9667            }
9668
9669            let _field = id.as_mut();
9670
9671            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9672
9673            let _field = server_end.as_mut();
9674
9675            ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
9676
9677            Ok(())
9678        }
9679    }
9680
9681    impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenRequest {
9682        type Natural = crate::natural::CapabilityStoreConnectorOpenRequest;
9683    }
9684
9685    impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenRequest {}
9686
9687    /// The wire type corresponding to [`CapabilityStoreConnectorOpenResponse`].
9688    #[derive(Clone, Debug)]
9689    #[repr(C)]
9690    pub struct CapabilityStoreConnectorOpenResponse {
9691        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9692    }
9693
9694    static_assertions::const_assert_eq!(
9695        std::mem::size_of::<CapabilityStoreConnectorOpenResponse>(),
9696        1
9697    );
9698    static_assertions::const_assert_eq!(
9699        std::mem::align_of::<CapabilityStoreConnectorOpenResponse>(),
9700        1
9701    );
9702
9703    unsafe impl ::fidl_next::Wire for CapabilityStoreConnectorOpenResponse {
9704        type Decoded<'de> = CapabilityStoreConnectorOpenResponse;
9705
9706        #[inline]
9707        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9708            ::fidl_next::munge! {
9709                let Self {
9710
9711                        _empty,
9712
9713
9714                } = &mut *out_;
9715            }
9716        }
9717    }
9718
9719    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreConnectorOpenResponse
9720    where
9721        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9722    {
9723        fn decode(
9724            slot_: ::fidl_next::Slot<'_, Self>,
9725            decoder_: &mut ___D,
9726            _: (),
9727        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9728            ::fidl_next::munge! {
9729                let Self {
9730
9731                        mut _empty,
9732
9733
9734                } = slot_;
9735            }
9736
9737            if _empty.as_bytes() != &[0u8] {
9738                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9739            }
9740
9741            Ok(())
9742        }
9743    }
9744
9745    impl ::fidl_next::IntoNatural for CapabilityStoreConnectorOpenResponse {
9746        type Natural = crate::natural::CapabilityStoreConnectorOpenResponse;
9747    }
9748
9749    impl ::fidl_next::Unconstrained for CapabilityStoreConnectorOpenResponse {}
9750
9751    /// The wire type corresponding to [`CapabilityStoreDirConnectorCreateResponse`].
9752    #[derive(Clone, Debug)]
9753    #[repr(C)]
9754    pub struct CapabilityStoreDirConnectorCreateResponse {
9755        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9756    }
9757
9758    static_assertions::const_assert_eq!(
9759        std::mem::size_of::<CapabilityStoreDirConnectorCreateResponse>(),
9760        1
9761    );
9762    static_assertions::const_assert_eq!(
9763        std::mem::align_of::<CapabilityStoreDirConnectorCreateResponse>(),
9764        1
9765    );
9766
9767    unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateResponse {
9768        type Decoded<'de> = CapabilityStoreDirConnectorCreateResponse;
9769
9770        #[inline]
9771        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9772            ::fidl_next::munge! {
9773                let Self {
9774
9775                        _empty,
9776
9777
9778                } = &mut *out_;
9779            }
9780        }
9781    }
9782
9783    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateResponse
9784    where
9785        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9786    {
9787        fn decode(
9788            slot_: ::fidl_next::Slot<'_, Self>,
9789            decoder_: &mut ___D,
9790            _: (),
9791        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9792            ::fidl_next::munge! {
9793                let Self {
9794
9795                        mut _empty,
9796
9797
9798                } = slot_;
9799            }
9800
9801            if _empty.as_bytes() != &[0u8] {
9802                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9803            }
9804
9805            Ok(())
9806        }
9807    }
9808
9809    impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateResponse {
9810        type Natural = crate::natural::CapabilityStoreDirConnectorCreateResponse;
9811    }
9812
9813    impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateResponse {}
9814
9815    /// The wire type corresponding to [`CapabilityStoreDirConnectorOpenResponse`].
9816    #[derive(Clone, Debug)]
9817    #[repr(C)]
9818    pub struct CapabilityStoreDirConnectorOpenResponse {
9819        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9820    }
9821
9822    static_assertions::const_assert_eq!(
9823        std::mem::size_of::<CapabilityStoreDirConnectorOpenResponse>(),
9824        1
9825    );
9826    static_assertions::const_assert_eq!(
9827        std::mem::align_of::<CapabilityStoreDirConnectorOpenResponse>(),
9828        1
9829    );
9830
9831    unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenResponse {
9832        type Decoded<'de> = CapabilityStoreDirConnectorOpenResponse;
9833
9834        #[inline]
9835        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9836            ::fidl_next::munge! {
9837                let Self {
9838
9839                        _empty,
9840
9841
9842                } = &mut *out_;
9843            }
9844        }
9845    }
9846
9847    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenResponse
9848    where
9849        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9850    {
9851        fn decode(
9852            slot_: ::fidl_next::Slot<'_, Self>,
9853            decoder_: &mut ___D,
9854            _: (),
9855        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9856            ::fidl_next::munge! {
9857                let Self {
9858
9859                        mut _empty,
9860
9861
9862                } = slot_;
9863            }
9864
9865            if _empty.as_bytes() != &[0u8] {
9866                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
9867            }
9868
9869            Ok(())
9870        }
9871    }
9872
9873    impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenResponse {
9874        type Natural = crate::natural::CapabilityStoreDirConnectorOpenResponse;
9875    }
9876
9877    impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenResponse {}
9878
9879    /// The wire type corresponding to [`CapabilityStoreDictionaryCreateRequest`].
9880    #[derive(Clone, Debug)]
9881    #[repr(C)]
9882    pub struct CapabilityStoreDictionaryCreateRequest {
9883        pub id: ::fidl_next::WireU64,
9884    }
9885
9886    static_assertions::const_assert_eq!(
9887        std::mem::size_of::<CapabilityStoreDictionaryCreateRequest>(),
9888        8
9889    );
9890    static_assertions::const_assert_eq!(
9891        std::mem::align_of::<CapabilityStoreDictionaryCreateRequest>(),
9892        8
9893    );
9894
9895    static_assertions::const_assert_eq!(
9896        std::mem::offset_of!(CapabilityStoreDictionaryCreateRequest, id),
9897        0
9898    );
9899
9900    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateRequest {
9901        type Decoded<'de> = CapabilityStoreDictionaryCreateRequest;
9902
9903        #[inline]
9904        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9905            ::fidl_next::munge! {
9906                let Self {
9907
9908                    id,
9909
9910                } = &mut *out_;
9911            }
9912
9913            ::fidl_next::Wire::zero_padding(id);
9914        }
9915    }
9916
9917    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateRequest
9918    where
9919        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9920    {
9921        fn decode(
9922            slot_: ::fidl_next::Slot<'_, Self>,
9923            decoder_: &mut ___D,
9924            _: (),
9925        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9926            ::fidl_next::munge! {
9927                let Self {
9928
9929                    mut id,
9930
9931                } = slot_;
9932            }
9933
9934            let _field = id.as_mut();
9935
9936            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
9937
9938            Ok(())
9939        }
9940    }
9941
9942    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateRequest {
9943        type Natural = crate::natural::CapabilityStoreDictionaryCreateRequest;
9944    }
9945
9946    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCreateRequest {}
9947
9948    /// The wire type corresponding to [`CapabilityStoreDictionaryCreateResponse`].
9949    #[derive(Clone, Debug)]
9950    #[repr(C)]
9951    pub struct CapabilityStoreDictionaryCreateResponse {
9952        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
9953    }
9954
9955    static_assertions::const_assert_eq!(
9956        std::mem::size_of::<CapabilityStoreDictionaryCreateResponse>(),
9957        1
9958    );
9959    static_assertions::const_assert_eq!(
9960        std::mem::align_of::<CapabilityStoreDictionaryCreateResponse>(),
9961        1
9962    );
9963
9964    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCreateResponse {
9965        type Decoded<'de> = CapabilityStoreDictionaryCreateResponse;
9966
9967        #[inline]
9968        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
9969            ::fidl_next::munge! {
9970                let Self {
9971
9972                        _empty,
9973
9974
9975                } = &mut *out_;
9976            }
9977        }
9978    }
9979
9980    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCreateResponse
9981    where
9982        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
9983    {
9984        fn decode(
9985            slot_: ::fidl_next::Slot<'_, Self>,
9986            decoder_: &mut ___D,
9987            _: (),
9988        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
9989            ::fidl_next::munge! {
9990                let Self {
9991
9992                        mut _empty,
9993
9994
9995                } = slot_;
9996            }
9997
9998            if _empty.as_bytes() != &[0u8] {
9999                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10000            }
10001
10002            Ok(())
10003        }
10004    }
10005
10006    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCreateResponse {
10007        type Natural = crate::natural::CapabilityStoreDictionaryCreateResponse;
10008    }
10009
10010    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCreateResponse {}
10011
10012    /// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportRequest`].
10013    #[derive(Debug)]
10014    #[repr(C)]
10015    pub struct CapabilityStoreDictionaryLegacyImportRequest {
10016        pub id: ::fidl_next::WireU64,
10017
10018        pub client_end: ::fidl_next::fuchsia::WireChannel,
10019    }
10020
10021    static_assertions::const_assert_eq!(
10022        std::mem::size_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
10023        16
10024    );
10025    static_assertions::const_assert_eq!(
10026        std::mem::align_of::<CapabilityStoreDictionaryLegacyImportRequest>(),
10027        8
10028    );
10029
10030    static_assertions::const_assert_eq!(
10031        std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, id),
10032        0
10033    );
10034
10035    static_assertions::const_assert_eq!(
10036        std::mem::offset_of!(CapabilityStoreDictionaryLegacyImportRequest, client_end),
10037        8
10038    );
10039
10040    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportRequest {
10041        type Decoded<'de> = CapabilityStoreDictionaryLegacyImportRequest;
10042
10043        #[inline]
10044        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10045            ::fidl_next::munge! {
10046                let Self {
10047
10048                    id,
10049                    client_end,
10050
10051                } = &mut *out_;
10052            }
10053
10054            ::fidl_next::Wire::zero_padding(id);
10055
10056            ::fidl_next::Wire::zero_padding(client_end);
10057
10058            unsafe {
10059                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10060            }
10061        }
10062    }
10063
10064    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportRequest
10065    where
10066        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10067        ___D: ::fidl_next::fuchsia::HandleDecoder,
10068    {
10069        fn decode(
10070            slot_: ::fidl_next::Slot<'_, Self>,
10071            decoder_: &mut ___D,
10072            _: (),
10073        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10074            if slot_.as_bytes()[12..16] != [0u8; 4] {
10075                return Err(::fidl_next::DecodeError::InvalidPadding);
10076            }
10077
10078            ::fidl_next::munge! {
10079                let Self {
10080
10081                    mut id,
10082                    mut client_end,
10083
10084                } = slot_;
10085            }
10086
10087            let _field = id.as_mut();
10088
10089            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10090
10091            let _field = client_end.as_mut();
10092
10093            ::fidl_next::Decode::decode(client_end.as_mut(), decoder_, ())?;
10094
10095            Ok(())
10096        }
10097    }
10098
10099    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportRequest {
10100        type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
10101    }
10102
10103    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportRequest {}
10104
10105    /// The wire type corresponding to [`CapabilityStoreDictionaryLegacyImportResponse`].
10106    #[derive(Clone, Debug)]
10107    #[repr(C)]
10108    pub struct CapabilityStoreDictionaryLegacyImportResponse {
10109        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10110    }
10111
10112    static_assertions::const_assert_eq!(
10113        std::mem::size_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
10114        1
10115    );
10116    static_assertions::const_assert_eq!(
10117        std::mem::align_of::<CapabilityStoreDictionaryLegacyImportResponse>(),
10118        1
10119    );
10120
10121    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyImportResponse {
10122        type Decoded<'de> = CapabilityStoreDictionaryLegacyImportResponse;
10123
10124        #[inline]
10125        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10126            ::fidl_next::munge! {
10127                let Self {
10128
10129                        _empty,
10130
10131
10132                } = &mut *out_;
10133            }
10134        }
10135    }
10136
10137    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyImportResponse
10138    where
10139        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10140    {
10141        fn decode(
10142            slot_: ::fidl_next::Slot<'_, Self>,
10143            decoder_: &mut ___D,
10144            _: (),
10145        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10146            ::fidl_next::munge! {
10147                let Self {
10148
10149                        mut _empty,
10150
10151
10152                } = slot_;
10153            }
10154
10155            if _empty.as_bytes() != &[0u8] {
10156                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10157            }
10158
10159            Ok(())
10160        }
10161    }
10162
10163    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyImportResponse {
10164        type Natural = crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
10165    }
10166
10167    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyImportResponse {}
10168
10169    /// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportRequest`].
10170    #[derive(Debug)]
10171    #[repr(C)]
10172    pub struct CapabilityStoreDictionaryLegacyExportRequest {
10173        pub id: ::fidl_next::WireU64,
10174
10175        pub server_end: ::fidl_next::fuchsia::WireChannel,
10176    }
10177
10178    static_assertions::const_assert_eq!(
10179        std::mem::size_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
10180        16
10181    );
10182    static_assertions::const_assert_eq!(
10183        std::mem::align_of::<CapabilityStoreDictionaryLegacyExportRequest>(),
10184        8
10185    );
10186
10187    static_assertions::const_assert_eq!(
10188        std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, id),
10189        0
10190    );
10191
10192    static_assertions::const_assert_eq!(
10193        std::mem::offset_of!(CapabilityStoreDictionaryLegacyExportRequest, server_end),
10194        8
10195    );
10196
10197    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportRequest {
10198        type Decoded<'de> = CapabilityStoreDictionaryLegacyExportRequest;
10199
10200        #[inline]
10201        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10202            ::fidl_next::munge! {
10203                let Self {
10204
10205                    id,
10206                    server_end,
10207
10208                } = &mut *out_;
10209            }
10210
10211            ::fidl_next::Wire::zero_padding(id);
10212
10213            ::fidl_next::Wire::zero_padding(server_end);
10214
10215            unsafe {
10216                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
10217            }
10218        }
10219    }
10220
10221    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportRequest
10222    where
10223        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10224        ___D: ::fidl_next::fuchsia::HandleDecoder,
10225    {
10226        fn decode(
10227            slot_: ::fidl_next::Slot<'_, Self>,
10228            decoder_: &mut ___D,
10229            _: (),
10230        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10231            if slot_.as_bytes()[12..16] != [0u8; 4] {
10232                return Err(::fidl_next::DecodeError::InvalidPadding);
10233            }
10234
10235            ::fidl_next::munge! {
10236                let Self {
10237
10238                    mut id,
10239                    mut server_end,
10240
10241                } = slot_;
10242            }
10243
10244            let _field = id.as_mut();
10245
10246            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10247
10248            let _field = server_end.as_mut();
10249
10250            ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
10251
10252            Ok(())
10253        }
10254    }
10255
10256    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportRequest {
10257        type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
10258    }
10259
10260    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportRequest {}
10261
10262    /// The wire type corresponding to [`CapabilityStoreDictionaryLegacyExportResponse`].
10263    #[derive(Clone, Debug)]
10264    #[repr(C)]
10265    pub struct CapabilityStoreDictionaryLegacyExportResponse {
10266        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10267    }
10268
10269    static_assertions::const_assert_eq!(
10270        std::mem::size_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
10271        1
10272    );
10273    static_assertions::const_assert_eq!(
10274        std::mem::align_of::<CapabilityStoreDictionaryLegacyExportResponse>(),
10275        1
10276    );
10277
10278    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryLegacyExportResponse {
10279        type Decoded<'de> = CapabilityStoreDictionaryLegacyExportResponse;
10280
10281        #[inline]
10282        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10283            ::fidl_next::munge! {
10284                let Self {
10285
10286                        _empty,
10287
10288
10289                } = &mut *out_;
10290            }
10291        }
10292    }
10293
10294    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryLegacyExportResponse
10295    where
10296        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10297    {
10298        fn decode(
10299            slot_: ::fidl_next::Slot<'_, Self>,
10300            decoder_: &mut ___D,
10301            _: (),
10302        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10303            ::fidl_next::munge! {
10304                let Self {
10305
10306                        mut _empty,
10307
10308
10309                } = slot_;
10310            }
10311
10312            if _empty.as_bytes() != &[0u8] {
10313                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10314            }
10315
10316            Ok(())
10317        }
10318    }
10319
10320    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryLegacyExportResponse {
10321        type Natural = crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
10322    }
10323
10324    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryLegacyExportResponse {}
10325
10326    /// The wire type corresponding to [`DictionaryKey`](crate::natural::DictionaryKey).
10327    pub type DictionaryKey<'de> = ::fidl_next::WireString<'de>;
10328
10329    /// The wire type corresponding to [`DictionaryItem`].
10330    #[derive(Debug)]
10331    #[repr(C)]
10332    pub struct DictionaryItem<'de> {
10333        pub key: ::fidl_next::WireString<'de>,
10334
10335        pub value: ::fidl_next::WireU64,
10336    }
10337
10338    static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryItem<'_>>(), 24);
10339    static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryItem<'_>>(), 8);
10340
10341    static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, key), 0);
10342
10343    static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryItem<'_>, value), 16);
10344
10345    unsafe impl ::fidl_next::Wire for DictionaryItem<'static> {
10346        type Decoded<'de> = DictionaryItem<'de>;
10347
10348        #[inline]
10349        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10350            ::fidl_next::munge! {
10351                let Self {
10352
10353                    key,
10354                    value,
10355
10356                } = &mut *out_;
10357            }
10358
10359            ::fidl_next::Wire::zero_padding(key);
10360
10361            ::fidl_next::Wire::zero_padding(value);
10362        }
10363    }
10364
10365    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryItem<'static>
10366    where
10367        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10368        ___D: ::fidl_next::Decoder,
10369    {
10370        fn decode(
10371            slot_: ::fidl_next::Slot<'_, Self>,
10372            decoder_: &mut ___D,
10373            _: (),
10374        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10375            ::fidl_next::munge! {
10376                let Self {
10377
10378                    mut key,
10379                    mut value,
10380
10381                } = slot_;
10382            }
10383
10384            let _field = key.as_mut();
10385            ::fidl_next::Constrained::validate(_field, 255)?;
10386            ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10387
10388            let key = unsafe { key.deref_unchecked() };
10389
10390            if key.len() > 255 {
10391                return Err(::fidl_next::DecodeError::VectorTooLong {
10392                    size: key.len() as u64,
10393                    limit: 255,
10394                });
10395            }
10396
10397            let _field = value.as_mut();
10398
10399            ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
10400
10401            Ok(())
10402        }
10403    }
10404
10405    impl<'de> ::fidl_next::IntoNatural for DictionaryItem<'de> {
10406        type Natural = crate::natural::DictionaryItem;
10407    }
10408
10409    impl ::fidl_next::Unconstrained for DictionaryItem<'static> {}
10410
10411    /// The wire type corresponding to [`CapabilityStoreDictionaryInsertRequest`].
10412    #[derive(Debug)]
10413    #[repr(C)]
10414    pub struct CapabilityStoreDictionaryInsertRequest<'de> {
10415        pub id: ::fidl_next::WireU64,
10416
10417        pub item: crate::wire::DictionaryItem<'de>,
10418    }
10419
10420    static_assertions::const_assert_eq!(
10421        std::mem::size_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
10422        32
10423    );
10424    static_assertions::const_assert_eq!(
10425        std::mem::align_of::<CapabilityStoreDictionaryInsertRequest<'_>>(),
10426        8
10427    );
10428
10429    static_assertions::const_assert_eq!(
10430        std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, id),
10431        0
10432    );
10433
10434    static_assertions::const_assert_eq!(
10435        std::mem::offset_of!(CapabilityStoreDictionaryInsertRequest<'_>, item),
10436        8
10437    );
10438
10439    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertRequest<'static> {
10440        type Decoded<'de> = CapabilityStoreDictionaryInsertRequest<'de>;
10441
10442        #[inline]
10443        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10444            ::fidl_next::munge! {
10445                let Self {
10446
10447                    id,
10448                    item,
10449
10450                } = &mut *out_;
10451            }
10452
10453            ::fidl_next::Wire::zero_padding(id);
10454
10455            ::fidl_next::Wire::zero_padding(item);
10456        }
10457    }
10458
10459    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertRequest<'static>
10460    where
10461        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10462        ___D: ::fidl_next::Decoder,
10463    {
10464        fn decode(
10465            slot_: ::fidl_next::Slot<'_, Self>,
10466            decoder_: &mut ___D,
10467            _: (),
10468        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10469            ::fidl_next::munge! {
10470                let Self {
10471
10472                    mut id,
10473                    mut item,
10474
10475                } = slot_;
10476            }
10477
10478            let _field = id.as_mut();
10479
10480            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10481
10482            let _field = item.as_mut();
10483
10484            ::fidl_next::Decode::decode(item.as_mut(), decoder_, ())?;
10485
10486            Ok(())
10487        }
10488    }
10489
10490    impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertRequest<'de> {
10491        type Natural = crate::natural::CapabilityStoreDictionaryInsertRequest;
10492    }
10493
10494    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryInsertRequest<'static> {}
10495
10496    /// The wire type corresponding to [`CapabilityStoreDictionaryInsertResponse`].
10497    #[derive(Clone, Debug)]
10498    #[repr(C)]
10499    pub struct CapabilityStoreDictionaryInsertResponse {
10500        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10501    }
10502
10503    static_assertions::const_assert_eq!(
10504        std::mem::size_of::<CapabilityStoreDictionaryInsertResponse>(),
10505        1
10506    );
10507    static_assertions::const_assert_eq!(
10508        std::mem::align_of::<CapabilityStoreDictionaryInsertResponse>(),
10509        1
10510    );
10511
10512    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryInsertResponse {
10513        type Decoded<'de> = CapabilityStoreDictionaryInsertResponse;
10514
10515        #[inline]
10516        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10517            ::fidl_next::munge! {
10518                let Self {
10519
10520                        _empty,
10521
10522
10523                } = &mut *out_;
10524            }
10525        }
10526    }
10527
10528    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryInsertResponse
10529    where
10530        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10531    {
10532        fn decode(
10533            slot_: ::fidl_next::Slot<'_, Self>,
10534            decoder_: &mut ___D,
10535            _: (),
10536        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10537            ::fidl_next::munge! {
10538                let Self {
10539
10540                        mut _empty,
10541
10542
10543                } = slot_;
10544            }
10545
10546            if _empty.as_bytes() != &[0u8] {
10547                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10548            }
10549
10550            Ok(())
10551        }
10552    }
10553
10554    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryInsertResponse {
10555        type Natural = crate::natural::CapabilityStoreDictionaryInsertResponse;
10556    }
10557
10558    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryInsertResponse {}
10559
10560    /// The wire type corresponding to [`CapabilityStoreDictionaryGetRequest`].
10561    #[derive(Debug)]
10562    #[repr(C)]
10563    pub struct CapabilityStoreDictionaryGetRequest<'de> {
10564        pub id: ::fidl_next::WireU64,
10565
10566        pub key: ::fidl_next::WireString<'de>,
10567
10568        pub dest_id: ::fidl_next::WireU64,
10569    }
10570
10571    static_assertions::const_assert_eq!(
10572        std::mem::size_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
10573        32
10574    );
10575    static_assertions::const_assert_eq!(
10576        std::mem::align_of::<CapabilityStoreDictionaryGetRequest<'_>>(),
10577        8
10578    );
10579
10580    static_assertions::const_assert_eq!(
10581        std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, id),
10582        0
10583    );
10584
10585    static_assertions::const_assert_eq!(
10586        std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, key),
10587        8
10588    );
10589
10590    static_assertions::const_assert_eq!(
10591        std::mem::offset_of!(CapabilityStoreDictionaryGetRequest<'_>, dest_id),
10592        24
10593    );
10594
10595    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetRequest<'static> {
10596        type Decoded<'de> = CapabilityStoreDictionaryGetRequest<'de>;
10597
10598        #[inline]
10599        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10600            ::fidl_next::munge! {
10601                let Self {
10602
10603                    id,
10604                    key,
10605                    dest_id,
10606
10607                } = &mut *out_;
10608            }
10609
10610            ::fidl_next::Wire::zero_padding(id);
10611
10612            ::fidl_next::Wire::zero_padding(key);
10613
10614            ::fidl_next::Wire::zero_padding(dest_id);
10615        }
10616    }
10617
10618    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetRequest<'static>
10619    where
10620        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10621        ___D: ::fidl_next::Decoder,
10622    {
10623        fn decode(
10624            slot_: ::fidl_next::Slot<'_, Self>,
10625            decoder_: &mut ___D,
10626            _: (),
10627        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10628            ::fidl_next::munge! {
10629                let Self {
10630
10631                    mut id,
10632                    mut key,
10633                    mut dest_id,
10634
10635                } = slot_;
10636            }
10637
10638            let _field = id.as_mut();
10639
10640            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10641
10642            let _field = key.as_mut();
10643            ::fidl_next::Constrained::validate(_field, 255)?;
10644            ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10645
10646            let key = unsafe { key.deref_unchecked() };
10647
10648            if key.len() > 255 {
10649                return Err(::fidl_next::DecodeError::VectorTooLong {
10650                    size: key.len() as u64,
10651                    limit: 255,
10652                });
10653            }
10654
10655            let _field = dest_id.as_mut();
10656
10657            ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
10658
10659            Ok(())
10660        }
10661    }
10662
10663    impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetRequest<'de> {
10664        type Natural = crate::natural::CapabilityStoreDictionaryGetRequest;
10665    }
10666
10667    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryGetRequest<'static> {}
10668
10669    /// The wire type corresponding to [`CapabilityStoreDictionaryGetResponse`].
10670    #[derive(Clone, Debug)]
10671    #[repr(C)]
10672    pub struct CapabilityStoreDictionaryGetResponse {
10673        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10674    }
10675
10676    static_assertions::const_assert_eq!(
10677        std::mem::size_of::<CapabilityStoreDictionaryGetResponse>(),
10678        1
10679    );
10680    static_assertions::const_assert_eq!(
10681        std::mem::align_of::<CapabilityStoreDictionaryGetResponse>(),
10682        1
10683    );
10684
10685    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryGetResponse {
10686        type Decoded<'de> = CapabilityStoreDictionaryGetResponse;
10687
10688        #[inline]
10689        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10690            ::fidl_next::munge! {
10691                let Self {
10692
10693                        _empty,
10694
10695
10696                } = &mut *out_;
10697            }
10698        }
10699    }
10700
10701    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryGetResponse
10702    where
10703        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10704    {
10705        fn decode(
10706            slot_: ::fidl_next::Slot<'_, Self>,
10707            decoder_: &mut ___D,
10708            _: (),
10709        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10710            ::fidl_next::munge! {
10711                let Self {
10712
10713                        mut _empty,
10714
10715
10716                } = slot_;
10717            }
10718
10719            if _empty.as_bytes() != &[0u8] {
10720                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10721            }
10722
10723            Ok(())
10724        }
10725    }
10726
10727    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryGetResponse {
10728        type Natural = crate::natural::CapabilityStoreDictionaryGetResponse;
10729    }
10730
10731    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryGetResponse {}
10732
10733    /// The wire type corresponding to [`WrappedCapabilityId`].
10734    #[derive(Clone, Debug)]
10735    #[repr(C)]
10736    pub struct WrappedCapabilityId {
10737        pub id: ::fidl_next::WireU64,
10738    }
10739
10740    static_assertions::const_assert_eq!(std::mem::size_of::<WrappedCapabilityId>(), 8);
10741    static_assertions::const_assert_eq!(std::mem::align_of::<WrappedCapabilityId>(), 8);
10742
10743    static_assertions::const_assert_eq!(std::mem::offset_of!(WrappedCapabilityId, id), 0);
10744
10745    unsafe impl ::fidl_next::Wire for WrappedCapabilityId {
10746        type Decoded<'de> = WrappedCapabilityId;
10747
10748        #[inline]
10749        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10750            ::fidl_next::munge! {
10751                let Self {
10752
10753                    id,
10754
10755                } = &mut *out_;
10756            }
10757
10758            ::fidl_next::Wire::zero_padding(id);
10759        }
10760    }
10761
10762    unsafe impl<___D> ::fidl_next::Decode<___D> for WrappedCapabilityId
10763    where
10764        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10765    {
10766        fn decode(
10767            slot_: ::fidl_next::Slot<'_, Self>,
10768            decoder_: &mut ___D,
10769            _: (),
10770        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10771            ::fidl_next::munge! {
10772                let Self {
10773
10774                    mut id,
10775
10776                } = slot_;
10777            }
10778
10779            let _field = id.as_mut();
10780
10781            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10782
10783            Ok(())
10784        }
10785    }
10786
10787    impl ::fidl_next::IntoNatural for WrappedCapabilityId {
10788        type Natural = crate::natural::WrappedCapabilityId;
10789    }
10790
10791    impl ::fidl_next::Unconstrained for WrappedCapabilityId {}
10792
10793    /// The wire type corresponding to [`WrappedNewCapabilityId`](crate::natural::WrappedNewCapabilityId).
10794    pub type WrappedNewCapabilityId = crate::wire::WrappedCapabilityId;
10795
10796    /// The wire type corresponding to [`CapabilityStoreDictionaryRemoveRequest`].
10797    #[derive(Debug)]
10798    #[repr(C)]
10799    pub struct CapabilityStoreDictionaryRemoveRequest<'de> {
10800        pub id: ::fidl_next::WireU64,
10801
10802        pub key: ::fidl_next::WireString<'de>,
10803
10804        pub dest_id: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
10805    }
10806
10807    static_assertions::const_assert_eq!(
10808        std::mem::size_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
10809        32
10810    );
10811    static_assertions::const_assert_eq!(
10812        std::mem::align_of::<CapabilityStoreDictionaryRemoveRequest<'_>>(),
10813        8
10814    );
10815
10816    static_assertions::const_assert_eq!(
10817        std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, id),
10818        0
10819    );
10820
10821    static_assertions::const_assert_eq!(
10822        std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, key),
10823        8
10824    );
10825
10826    static_assertions::const_assert_eq!(
10827        std::mem::offset_of!(CapabilityStoreDictionaryRemoveRequest<'_>, dest_id),
10828        24
10829    );
10830
10831    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveRequest<'static> {
10832        type Decoded<'de> = CapabilityStoreDictionaryRemoveRequest<'de>;
10833
10834        #[inline]
10835        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10836            ::fidl_next::munge! {
10837                let Self {
10838
10839                    id,
10840                    key,
10841                    dest_id,
10842
10843                } = &mut *out_;
10844            }
10845
10846            ::fidl_next::Wire::zero_padding(id);
10847
10848            ::fidl_next::Wire::zero_padding(key);
10849
10850            ::fidl_next::Wire::zero_padding(dest_id);
10851        }
10852    }
10853
10854    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveRequest<'static>
10855    where
10856        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10857        ___D: ::fidl_next::Decoder,
10858    {
10859        fn decode(
10860            slot_: ::fidl_next::Slot<'_, Self>,
10861            decoder_: &mut ___D,
10862            _: (),
10863        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10864            ::fidl_next::munge! {
10865                let Self {
10866
10867                    mut id,
10868                    mut key,
10869                    mut dest_id,
10870
10871                } = slot_;
10872            }
10873
10874            let _field = id.as_mut();
10875
10876            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
10877
10878            let _field = key.as_mut();
10879            ::fidl_next::Constrained::validate(_field, 255)?;
10880            ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
10881
10882            let key = unsafe { key.deref_unchecked() };
10883
10884            if key.len() > 255 {
10885                return Err(::fidl_next::DecodeError::VectorTooLong {
10886                    size: key.len() as u64,
10887                    limit: 255,
10888                });
10889            }
10890
10891            let _field = dest_id.as_mut();
10892
10893            ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
10894
10895            Ok(())
10896        }
10897    }
10898
10899    impl<'de> ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveRequest<'de> {
10900        type Natural = crate::natural::CapabilityStoreDictionaryRemoveRequest;
10901    }
10902
10903    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryRemoveRequest<'static> {}
10904
10905    /// The wire type corresponding to [`CapabilityStoreDictionaryRemoveResponse`].
10906    #[derive(Clone, Debug)]
10907    #[repr(C)]
10908    pub struct CapabilityStoreDictionaryRemoveResponse {
10909        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
10910    }
10911
10912    static_assertions::const_assert_eq!(
10913        std::mem::size_of::<CapabilityStoreDictionaryRemoveResponse>(),
10914        1
10915    );
10916    static_assertions::const_assert_eq!(
10917        std::mem::align_of::<CapabilityStoreDictionaryRemoveResponse>(),
10918        1
10919    );
10920
10921    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryRemoveResponse {
10922        type Decoded<'de> = CapabilityStoreDictionaryRemoveResponse;
10923
10924        #[inline]
10925        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10926            ::fidl_next::munge! {
10927                let Self {
10928
10929                        _empty,
10930
10931
10932                } = &mut *out_;
10933            }
10934        }
10935    }
10936
10937    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryRemoveResponse
10938    where
10939        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10940    {
10941        fn decode(
10942            slot_: ::fidl_next::Slot<'_, Self>,
10943            decoder_: &mut ___D,
10944            _: (),
10945        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10946            ::fidl_next::munge! {
10947                let Self {
10948
10949                        mut _empty,
10950
10951
10952                } = slot_;
10953            }
10954
10955            if _empty.as_bytes() != &[0u8] {
10956                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
10957            }
10958
10959            Ok(())
10960        }
10961    }
10962
10963    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryRemoveResponse {
10964        type Natural = crate::natural::CapabilityStoreDictionaryRemoveResponse;
10965    }
10966
10967    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryRemoveResponse {}
10968
10969    /// The wire type corresponding to [`CapabilityStoreDictionaryCopyRequest`].
10970    #[derive(Clone, Debug)]
10971    #[repr(C)]
10972    pub struct CapabilityStoreDictionaryCopyRequest {
10973        pub id: ::fidl_next::WireU64,
10974
10975        pub dest_id: ::fidl_next::WireU64,
10976    }
10977
10978    static_assertions::const_assert_eq!(
10979        std::mem::size_of::<CapabilityStoreDictionaryCopyRequest>(),
10980        16
10981    );
10982    static_assertions::const_assert_eq!(
10983        std::mem::align_of::<CapabilityStoreDictionaryCopyRequest>(),
10984        8
10985    );
10986
10987    static_assertions::const_assert_eq!(
10988        std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, id),
10989        0
10990    );
10991
10992    static_assertions::const_assert_eq!(
10993        std::mem::offset_of!(CapabilityStoreDictionaryCopyRequest, dest_id),
10994        8
10995    );
10996
10997    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyRequest {
10998        type Decoded<'de> = CapabilityStoreDictionaryCopyRequest;
10999
11000        #[inline]
11001        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11002            ::fidl_next::munge! {
11003                let Self {
11004
11005                    id,
11006                    dest_id,
11007
11008                } = &mut *out_;
11009            }
11010
11011            ::fidl_next::Wire::zero_padding(id);
11012
11013            ::fidl_next::Wire::zero_padding(dest_id);
11014        }
11015    }
11016
11017    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyRequest
11018    where
11019        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11020    {
11021        fn decode(
11022            slot_: ::fidl_next::Slot<'_, Self>,
11023            decoder_: &mut ___D,
11024            _: (),
11025        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11026            ::fidl_next::munge! {
11027                let Self {
11028
11029                    mut id,
11030                    mut dest_id,
11031
11032                } = slot_;
11033            }
11034
11035            let _field = id.as_mut();
11036
11037            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11038
11039            let _field = dest_id.as_mut();
11040
11041            ::fidl_next::Decode::decode(dest_id.as_mut(), decoder_, ())?;
11042
11043            Ok(())
11044        }
11045    }
11046
11047    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyRequest {
11048        type Natural = crate::natural::CapabilityStoreDictionaryCopyRequest;
11049    }
11050
11051    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCopyRequest {}
11052
11053    /// The wire type corresponding to [`CapabilityStoreDictionaryCopyResponse`].
11054    #[derive(Clone, Debug)]
11055    #[repr(C)]
11056    pub struct CapabilityStoreDictionaryCopyResponse {
11057        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11058    }
11059
11060    static_assertions::const_assert_eq!(
11061        std::mem::size_of::<CapabilityStoreDictionaryCopyResponse>(),
11062        1
11063    );
11064    static_assertions::const_assert_eq!(
11065        std::mem::align_of::<CapabilityStoreDictionaryCopyResponse>(),
11066        1
11067    );
11068
11069    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryCopyResponse {
11070        type Decoded<'de> = CapabilityStoreDictionaryCopyResponse;
11071
11072        #[inline]
11073        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11074            ::fidl_next::munge! {
11075                let Self {
11076
11077                        _empty,
11078
11079
11080                } = &mut *out_;
11081            }
11082        }
11083    }
11084
11085    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryCopyResponse
11086    where
11087        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11088    {
11089        fn decode(
11090            slot_: ::fidl_next::Slot<'_, Self>,
11091            decoder_: &mut ___D,
11092            _: (),
11093        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11094            ::fidl_next::munge! {
11095                let Self {
11096
11097                        mut _empty,
11098
11099
11100                } = slot_;
11101            }
11102
11103            if _empty.as_bytes() != &[0u8] {
11104                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11105            }
11106
11107            Ok(())
11108        }
11109    }
11110
11111    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryCopyResponse {
11112        type Natural = crate::natural::CapabilityStoreDictionaryCopyResponse;
11113    }
11114
11115    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryCopyResponse {}
11116
11117    /// The wire type corresponding to [`CapabilityStoreDictionaryKeysRequest`].
11118    #[derive(Debug)]
11119    #[repr(C)]
11120    pub struct CapabilityStoreDictionaryKeysRequest {
11121        pub id: ::fidl_next::WireU64,
11122
11123        pub iterator: ::fidl_next::ServerEnd<
11124            crate::DictionaryKeysIterator,
11125            ::fidl_next::fuchsia::WireChannel,
11126        >,
11127    }
11128
11129    static_assertions::const_assert_eq!(
11130        std::mem::size_of::<CapabilityStoreDictionaryKeysRequest>(),
11131        16
11132    );
11133    static_assertions::const_assert_eq!(
11134        std::mem::align_of::<CapabilityStoreDictionaryKeysRequest>(),
11135        8
11136    );
11137
11138    static_assertions::const_assert_eq!(
11139        std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, id),
11140        0
11141    );
11142
11143    static_assertions::const_assert_eq!(
11144        std::mem::offset_of!(CapabilityStoreDictionaryKeysRequest, iterator),
11145        8
11146    );
11147
11148    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysRequest {
11149        type Decoded<'de> = CapabilityStoreDictionaryKeysRequest;
11150
11151        #[inline]
11152        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11153            ::fidl_next::munge! {
11154                let Self {
11155
11156                    id,
11157                    iterator,
11158
11159                } = &mut *out_;
11160            }
11161
11162            ::fidl_next::Wire::zero_padding(id);
11163
11164            ::fidl_next::Wire::zero_padding(iterator);
11165
11166            unsafe {
11167                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11168            }
11169        }
11170    }
11171
11172    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysRequest
11173    where
11174        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11175        ___D: ::fidl_next::fuchsia::HandleDecoder,
11176    {
11177        fn decode(
11178            slot_: ::fidl_next::Slot<'_, Self>,
11179            decoder_: &mut ___D,
11180            _: (),
11181        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11182            if slot_.as_bytes()[12..16] != [0u8; 4] {
11183                return Err(::fidl_next::DecodeError::InvalidPadding);
11184            }
11185
11186            ::fidl_next::munge! {
11187                let Self {
11188
11189                    mut id,
11190                    mut iterator,
11191
11192                } = slot_;
11193            }
11194
11195            let _field = id.as_mut();
11196
11197            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11198
11199            let _field = iterator.as_mut();
11200
11201            ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11202
11203            Ok(())
11204        }
11205    }
11206
11207    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysRequest {
11208        type Natural = crate::natural::CapabilityStoreDictionaryKeysRequest;
11209    }
11210
11211    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysRequest {}
11212
11213    /// The wire type corresponding to [`CapabilityStoreDictionaryKeysResponse`].
11214    #[derive(Clone, Debug)]
11215    #[repr(C)]
11216    pub struct CapabilityStoreDictionaryKeysResponse {
11217        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11218    }
11219
11220    static_assertions::const_assert_eq!(
11221        std::mem::size_of::<CapabilityStoreDictionaryKeysResponse>(),
11222        1
11223    );
11224    static_assertions::const_assert_eq!(
11225        std::mem::align_of::<CapabilityStoreDictionaryKeysResponse>(),
11226        1
11227    );
11228
11229    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryKeysResponse {
11230        type Decoded<'de> = CapabilityStoreDictionaryKeysResponse;
11231
11232        #[inline]
11233        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11234            ::fidl_next::munge! {
11235                let Self {
11236
11237                        _empty,
11238
11239
11240                } = &mut *out_;
11241            }
11242        }
11243    }
11244
11245    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryKeysResponse
11246    where
11247        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11248    {
11249        fn decode(
11250            slot_: ::fidl_next::Slot<'_, Self>,
11251            decoder_: &mut ___D,
11252            _: (),
11253        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11254            ::fidl_next::munge! {
11255                let Self {
11256
11257                        mut _empty,
11258
11259
11260                } = slot_;
11261            }
11262
11263            if _empty.as_bytes() != &[0u8] {
11264                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11265            }
11266
11267            Ok(())
11268        }
11269    }
11270
11271    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryKeysResponse {
11272        type Natural = crate::natural::CapabilityStoreDictionaryKeysResponse;
11273    }
11274
11275    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryKeysResponse {}
11276
11277    /// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateRequest`].
11278    #[derive(Debug)]
11279    #[repr(C)]
11280    pub struct CapabilityStoreDictionaryEnumerateRequest {
11281        pub id: ::fidl_next::WireU64,
11282
11283        pub iterator: ::fidl_next::ServerEnd<
11284            crate::DictionaryEnumerateIterator,
11285            ::fidl_next::fuchsia::WireChannel,
11286        >,
11287    }
11288
11289    static_assertions::const_assert_eq!(
11290        std::mem::size_of::<CapabilityStoreDictionaryEnumerateRequest>(),
11291        16
11292    );
11293    static_assertions::const_assert_eq!(
11294        std::mem::align_of::<CapabilityStoreDictionaryEnumerateRequest>(),
11295        8
11296    );
11297
11298    static_assertions::const_assert_eq!(
11299        std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, id),
11300        0
11301    );
11302
11303    static_assertions::const_assert_eq!(
11304        std::mem::offset_of!(CapabilityStoreDictionaryEnumerateRequest, iterator),
11305        8
11306    );
11307
11308    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateRequest {
11309        type Decoded<'de> = CapabilityStoreDictionaryEnumerateRequest;
11310
11311        #[inline]
11312        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11313            ::fidl_next::munge! {
11314                let Self {
11315
11316                    id,
11317                    iterator,
11318
11319                } = &mut *out_;
11320            }
11321
11322            ::fidl_next::Wire::zero_padding(id);
11323
11324            ::fidl_next::Wire::zero_padding(iterator);
11325
11326            unsafe {
11327                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11328            }
11329        }
11330    }
11331
11332    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateRequest
11333    where
11334        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11335        ___D: ::fidl_next::fuchsia::HandleDecoder,
11336    {
11337        fn decode(
11338            slot_: ::fidl_next::Slot<'_, Self>,
11339            decoder_: &mut ___D,
11340            _: (),
11341        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11342            if slot_.as_bytes()[12..16] != [0u8; 4] {
11343                return Err(::fidl_next::DecodeError::InvalidPadding);
11344            }
11345
11346            ::fidl_next::munge! {
11347                let Self {
11348
11349                    mut id,
11350                    mut iterator,
11351
11352                } = slot_;
11353            }
11354
11355            let _field = id.as_mut();
11356
11357            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11358
11359            let _field = iterator.as_mut();
11360
11361            ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11362
11363            Ok(())
11364        }
11365    }
11366
11367    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateRequest {
11368        type Natural = crate::natural::CapabilityStoreDictionaryEnumerateRequest;
11369    }
11370
11371    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateRequest {}
11372
11373    /// The wire type corresponding to [`CapabilityStoreDictionaryEnumerateResponse`].
11374    #[derive(Clone, Debug)]
11375    #[repr(C)]
11376    pub struct CapabilityStoreDictionaryEnumerateResponse {
11377        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11378    }
11379
11380    static_assertions::const_assert_eq!(
11381        std::mem::size_of::<CapabilityStoreDictionaryEnumerateResponse>(),
11382        1
11383    );
11384    static_assertions::const_assert_eq!(
11385        std::mem::align_of::<CapabilityStoreDictionaryEnumerateResponse>(),
11386        1
11387    );
11388
11389    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryEnumerateResponse {
11390        type Decoded<'de> = CapabilityStoreDictionaryEnumerateResponse;
11391
11392        #[inline]
11393        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11394            ::fidl_next::munge! {
11395                let Self {
11396
11397                        _empty,
11398
11399
11400                } = &mut *out_;
11401            }
11402        }
11403    }
11404
11405    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryEnumerateResponse
11406    where
11407        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11408    {
11409        fn decode(
11410            slot_: ::fidl_next::Slot<'_, Self>,
11411            decoder_: &mut ___D,
11412            _: (),
11413        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11414            ::fidl_next::munge! {
11415                let Self {
11416
11417                        mut _empty,
11418
11419
11420                } = slot_;
11421            }
11422
11423            if _empty.as_bytes() != &[0u8] {
11424                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11425            }
11426
11427            Ok(())
11428        }
11429    }
11430
11431    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryEnumerateResponse {
11432        type Natural = crate::natural::CapabilityStoreDictionaryEnumerateResponse;
11433    }
11434
11435    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryEnumerateResponse {}
11436
11437    /// The wire type corresponding to [`CapabilityStoreDictionaryDrainRequest`].
11438    #[derive(Debug)]
11439    #[repr(C)]
11440    pub struct CapabilityStoreDictionaryDrainRequest {
11441        pub id: ::fidl_next::WireU64,
11442
11443        pub iterator: ::fidl_next::ServerEnd<
11444            crate::DictionaryDrainIterator,
11445            ::fidl_next::fuchsia::WireOptionalChannel,
11446        >,
11447    }
11448
11449    static_assertions::const_assert_eq!(
11450        std::mem::size_of::<CapabilityStoreDictionaryDrainRequest>(),
11451        16
11452    );
11453    static_assertions::const_assert_eq!(
11454        std::mem::align_of::<CapabilityStoreDictionaryDrainRequest>(),
11455        8
11456    );
11457
11458    static_assertions::const_assert_eq!(
11459        std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, id),
11460        0
11461    );
11462
11463    static_assertions::const_assert_eq!(
11464        std::mem::offset_of!(CapabilityStoreDictionaryDrainRequest, iterator),
11465        8
11466    );
11467
11468    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainRequest {
11469        type Decoded<'de> = CapabilityStoreDictionaryDrainRequest;
11470
11471        #[inline]
11472        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11473            ::fidl_next::munge! {
11474                let Self {
11475
11476                    id,
11477                    iterator,
11478
11479                } = &mut *out_;
11480            }
11481
11482            ::fidl_next::Wire::zero_padding(id);
11483
11484            ::fidl_next::Wire::zero_padding(iterator);
11485
11486            unsafe {
11487                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11488            }
11489        }
11490    }
11491
11492    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainRequest
11493    where
11494        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11495        ___D: ::fidl_next::fuchsia::HandleDecoder,
11496    {
11497        fn decode(
11498            slot_: ::fidl_next::Slot<'_, Self>,
11499            decoder_: &mut ___D,
11500            _: (),
11501        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11502            if slot_.as_bytes()[12..16] != [0u8; 4] {
11503                return Err(::fidl_next::DecodeError::InvalidPadding);
11504            }
11505
11506            ::fidl_next::munge! {
11507                let Self {
11508
11509                    mut id,
11510                    mut iterator,
11511
11512                } = slot_;
11513            }
11514
11515            let _field = id.as_mut();
11516
11517            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11518
11519            let _field = iterator.as_mut();
11520
11521            ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
11522
11523            Ok(())
11524        }
11525    }
11526
11527    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainRequest {
11528        type Natural = crate::natural::CapabilityStoreDictionaryDrainRequest;
11529    }
11530
11531    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainRequest {}
11532
11533    /// The wire type corresponding to [`CapabilityStoreDictionaryDrainResponse`].
11534    #[derive(Clone, Debug)]
11535    #[repr(C)]
11536    pub struct CapabilityStoreDictionaryDrainResponse {
11537        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
11538    }
11539
11540    static_assertions::const_assert_eq!(
11541        std::mem::size_of::<CapabilityStoreDictionaryDrainResponse>(),
11542        1
11543    );
11544    static_assertions::const_assert_eq!(
11545        std::mem::align_of::<CapabilityStoreDictionaryDrainResponse>(),
11546        1
11547    );
11548
11549    unsafe impl ::fidl_next::Wire for CapabilityStoreDictionaryDrainResponse {
11550        type Decoded<'de> = CapabilityStoreDictionaryDrainResponse;
11551
11552        #[inline]
11553        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11554            ::fidl_next::munge! {
11555                let Self {
11556
11557                        _empty,
11558
11559
11560                } = &mut *out_;
11561            }
11562        }
11563    }
11564
11565    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDictionaryDrainResponse
11566    where
11567        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11568    {
11569        fn decode(
11570            slot_: ::fidl_next::Slot<'_, Self>,
11571            decoder_: &mut ___D,
11572            _: (),
11573        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11574            ::fidl_next::munge! {
11575                let Self {
11576
11577                        mut _empty,
11578
11579
11580                } = slot_;
11581            }
11582
11583            if _empty.as_bytes() != &[0u8] {
11584                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
11585            }
11586
11587            Ok(())
11588        }
11589    }
11590
11591    impl ::fidl_next::IntoNatural for CapabilityStoreDictionaryDrainResponse {
11592        type Natural = crate::natural::CapabilityStoreDictionaryDrainResponse;
11593    }
11594
11595    impl ::fidl_next::Unconstrained for CapabilityStoreDictionaryDrainResponse {}
11596
11597    /// The wire type corresponding to [`CapabilityStoreExportResponse`].
11598    #[derive(Debug)]
11599    #[repr(C)]
11600    pub struct CapabilityStoreExportResponse<'de> {
11601        pub capability: crate::wire::Capability<'de>,
11602    }
11603
11604    static_assertions::const_assert_eq!(
11605        std::mem::size_of::<CapabilityStoreExportResponse<'_>>(),
11606        16
11607    );
11608    static_assertions::const_assert_eq!(
11609        std::mem::align_of::<CapabilityStoreExportResponse<'_>>(),
11610        8
11611    );
11612
11613    static_assertions::const_assert_eq!(
11614        std::mem::offset_of!(CapabilityStoreExportResponse<'_>, capability),
11615        0
11616    );
11617
11618    unsafe impl ::fidl_next::Wire for CapabilityStoreExportResponse<'static> {
11619        type Decoded<'de> = CapabilityStoreExportResponse<'de>;
11620
11621        #[inline]
11622        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11623            ::fidl_next::munge! {
11624                let Self {
11625
11626                    capability,
11627
11628                } = &mut *out_;
11629            }
11630
11631            ::fidl_next::Wire::zero_padding(capability);
11632        }
11633    }
11634
11635    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreExportResponse<'static>
11636    where
11637        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11638        ___D: ::fidl_next::Decoder,
11639        ___D: ::fidl_next::fuchsia::HandleDecoder,
11640    {
11641        fn decode(
11642            slot_: ::fidl_next::Slot<'_, Self>,
11643            decoder_: &mut ___D,
11644            _: (),
11645        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11646            ::fidl_next::munge! {
11647                let Self {
11648
11649                    mut capability,
11650
11651                } = slot_;
11652            }
11653
11654            let _field = capability.as_mut();
11655
11656            ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
11657
11658            Ok(())
11659        }
11660    }
11661
11662    impl<'de> ::fidl_next::IntoNatural for CapabilityStoreExportResponse<'de> {
11663        type Natural = crate::natural::CapabilityStoreExportResponse;
11664    }
11665
11666    impl ::fidl_next::Unconstrained for CapabilityStoreExportResponse<'static> {}
11667
11668    /// The wire type corresponding to [`CapabilityStoreImportRequest`].
11669    #[derive(Debug)]
11670    #[repr(C)]
11671    pub struct CapabilityStoreImportRequest<'de> {
11672        pub id: ::fidl_next::WireU64,
11673
11674        pub capability: crate::wire::Capability<'de>,
11675    }
11676
11677    static_assertions::const_assert_eq!(
11678        std::mem::size_of::<CapabilityStoreImportRequest<'_>>(),
11679        24
11680    );
11681    static_assertions::const_assert_eq!(
11682        std::mem::align_of::<CapabilityStoreImportRequest<'_>>(),
11683        8
11684    );
11685
11686    static_assertions::const_assert_eq!(
11687        std::mem::offset_of!(CapabilityStoreImportRequest<'_>, id),
11688        0
11689    );
11690
11691    static_assertions::const_assert_eq!(
11692        std::mem::offset_of!(CapabilityStoreImportRequest<'_>, capability),
11693        8
11694    );
11695
11696    unsafe impl ::fidl_next::Wire for CapabilityStoreImportRequest<'static> {
11697        type Decoded<'de> = CapabilityStoreImportRequest<'de>;
11698
11699        #[inline]
11700        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11701            ::fidl_next::munge! {
11702                let Self {
11703
11704                    id,
11705                    capability,
11706
11707                } = &mut *out_;
11708            }
11709
11710            ::fidl_next::Wire::zero_padding(id);
11711
11712            ::fidl_next::Wire::zero_padding(capability);
11713        }
11714    }
11715
11716    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreImportRequest<'static>
11717    where
11718        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11719        ___D: ::fidl_next::Decoder,
11720        ___D: ::fidl_next::fuchsia::HandleDecoder,
11721    {
11722        fn decode(
11723            slot_: ::fidl_next::Slot<'_, Self>,
11724            decoder_: &mut ___D,
11725            _: (),
11726        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11727            ::fidl_next::munge! {
11728                let Self {
11729
11730                    mut id,
11731                    mut capability,
11732
11733                } = slot_;
11734            }
11735
11736            let _field = id.as_mut();
11737
11738            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11739
11740            let _field = capability.as_mut();
11741
11742            ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
11743
11744            Ok(())
11745        }
11746    }
11747
11748    impl<'de> ::fidl_next::IntoNatural for CapabilityStoreImportRequest<'de> {
11749        type Natural = crate::natural::CapabilityStoreImportRequest;
11750    }
11751
11752    impl ::fidl_next::Unconstrained for CapabilityStoreImportRequest<'static> {}
11753
11754    /// The wire type corresponding to [`CapabilityStoreDirConnectorCreateRequest`].
11755    #[derive(Debug)]
11756    #[repr(C)]
11757    pub struct CapabilityStoreDirConnectorCreateRequest {
11758        pub id: ::fidl_next::WireU64,
11759
11760        pub receiver: ::fidl_next::ClientEnd<crate::DirReceiver, ::fidl_next::fuchsia::WireChannel>,
11761    }
11762
11763    static_assertions::const_assert_eq!(
11764        std::mem::size_of::<CapabilityStoreDirConnectorCreateRequest>(),
11765        16
11766    );
11767    static_assertions::const_assert_eq!(
11768        std::mem::align_of::<CapabilityStoreDirConnectorCreateRequest>(),
11769        8
11770    );
11771
11772    static_assertions::const_assert_eq!(
11773        std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, id),
11774        0
11775    );
11776
11777    static_assertions::const_assert_eq!(
11778        std::mem::offset_of!(CapabilityStoreDirConnectorCreateRequest, receiver),
11779        8
11780    );
11781
11782    unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorCreateRequest {
11783        type Decoded<'de> = CapabilityStoreDirConnectorCreateRequest;
11784
11785        #[inline]
11786        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11787            ::fidl_next::munge! {
11788                let Self {
11789
11790                    id,
11791                    receiver,
11792
11793                } = &mut *out_;
11794            }
11795
11796            ::fidl_next::Wire::zero_padding(id);
11797
11798            ::fidl_next::Wire::zero_padding(receiver);
11799
11800            unsafe {
11801                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11802            }
11803        }
11804    }
11805
11806    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorCreateRequest
11807    where
11808        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11809        ___D: ::fidl_next::fuchsia::HandleDecoder,
11810    {
11811        fn decode(
11812            slot_: ::fidl_next::Slot<'_, Self>,
11813            decoder_: &mut ___D,
11814            _: (),
11815        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11816            if slot_.as_bytes()[12..16] != [0u8; 4] {
11817                return Err(::fidl_next::DecodeError::InvalidPadding);
11818            }
11819
11820            ::fidl_next::munge! {
11821                let Self {
11822
11823                    mut id,
11824                    mut receiver,
11825
11826                } = slot_;
11827            }
11828
11829            let _field = id.as_mut();
11830
11831            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11832
11833            let _field = receiver.as_mut();
11834
11835            ::fidl_next::Decode::decode(receiver.as_mut(), decoder_, ())?;
11836
11837            Ok(())
11838        }
11839    }
11840
11841    impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorCreateRequest {
11842        type Natural = crate::natural::CapabilityStoreDirConnectorCreateRequest;
11843    }
11844
11845    impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorCreateRequest {}
11846
11847    /// The wire type corresponding to [`CapabilityStoreDirConnectorOpenRequest`].
11848    #[derive(Debug)]
11849    #[repr(C)]
11850    pub struct CapabilityStoreDirConnectorOpenRequest {
11851        pub id: ::fidl_next::WireU64,
11852
11853        pub server_end: ::fidl_next::ServerEnd<
11854            ::fidl_next_fuchsia_io::Directory,
11855            ::fidl_next::fuchsia::WireChannel,
11856        >,
11857    }
11858
11859    static_assertions::const_assert_eq!(
11860        std::mem::size_of::<CapabilityStoreDirConnectorOpenRequest>(),
11861        16
11862    );
11863    static_assertions::const_assert_eq!(
11864        std::mem::align_of::<CapabilityStoreDirConnectorOpenRequest>(),
11865        8
11866    );
11867
11868    static_assertions::const_assert_eq!(
11869        std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, id),
11870        0
11871    );
11872
11873    static_assertions::const_assert_eq!(
11874        std::mem::offset_of!(CapabilityStoreDirConnectorOpenRequest, server_end),
11875        8
11876    );
11877
11878    unsafe impl ::fidl_next::Wire for CapabilityStoreDirConnectorOpenRequest {
11879        type Decoded<'de> = CapabilityStoreDirConnectorOpenRequest;
11880
11881        #[inline]
11882        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11883            ::fidl_next::munge! {
11884                let Self {
11885
11886                    id,
11887                    server_end,
11888
11889                } = &mut *out_;
11890            }
11891
11892            ::fidl_next::Wire::zero_padding(id);
11893
11894            ::fidl_next::Wire::zero_padding(server_end);
11895
11896            unsafe {
11897                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
11898            }
11899        }
11900    }
11901
11902    unsafe impl<___D> ::fidl_next::Decode<___D> for CapabilityStoreDirConnectorOpenRequest
11903    where
11904        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11905        ___D: ::fidl_next::fuchsia::HandleDecoder,
11906    {
11907        fn decode(
11908            slot_: ::fidl_next::Slot<'_, Self>,
11909            decoder_: &mut ___D,
11910            _: (),
11911        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11912            if slot_.as_bytes()[12..16] != [0u8; 4] {
11913                return Err(::fidl_next::DecodeError::InvalidPadding);
11914            }
11915
11916            ::fidl_next::munge! {
11917                let Self {
11918
11919                    mut id,
11920                    mut server_end,
11921
11922                } = slot_;
11923            }
11924
11925            let _field = id.as_mut();
11926
11927            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11928
11929            let _field = server_end.as_mut();
11930
11931            ::fidl_next::Decode::decode(server_end.as_mut(), decoder_, ())?;
11932
11933            Ok(())
11934        }
11935    }
11936
11937    impl ::fidl_next::IntoNatural for CapabilityStoreDirConnectorOpenRequest {
11938        type Natural = crate::natural::CapabilityStoreDirConnectorOpenRequest;
11939    }
11940
11941    impl ::fidl_next::Unconstrained for CapabilityStoreDirConnectorOpenRequest {}
11942
11943    /// The wire type corresponding to [`InstanceToken`].
11944    #[derive(Debug)]
11945    #[repr(C)]
11946    pub struct InstanceToken {
11947        pub token: ::fidl_next::fuchsia::WireEventPair,
11948    }
11949
11950    static_assertions::const_assert_eq!(std::mem::size_of::<InstanceToken>(), 4);
11951    static_assertions::const_assert_eq!(std::mem::align_of::<InstanceToken>(), 4);
11952
11953    static_assertions::const_assert_eq!(std::mem::offset_of!(InstanceToken, token), 0);
11954
11955    unsafe impl ::fidl_next::Wire for InstanceToken {
11956        type Decoded<'de> = InstanceToken;
11957
11958        #[inline]
11959        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11960            ::fidl_next::munge! {
11961                let Self {
11962
11963                    token,
11964
11965                } = &mut *out_;
11966            }
11967
11968            ::fidl_next::Wire::zero_padding(token);
11969        }
11970    }
11971
11972    unsafe impl<___D> ::fidl_next::Decode<___D> for InstanceToken
11973    where
11974        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11975        ___D: ::fidl_next::fuchsia::HandleDecoder,
11976    {
11977        fn decode(
11978            slot_: ::fidl_next::Slot<'_, Self>,
11979            decoder_: &mut ___D,
11980            _: (),
11981        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11982            ::fidl_next::munge! {
11983                let Self {
11984
11985                    mut token,
11986
11987                } = slot_;
11988            }
11989
11990            let _field = token.as_mut();
11991
11992            ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
11993
11994            Ok(())
11995        }
11996    }
11997
11998    impl ::fidl_next::IntoNatural for InstanceToken {
11999        type Natural = crate::natural::InstanceToken;
12000    }
12001
12002    impl ::fidl_next::Unconstrained for InstanceToken {}
12003
12004    /// The wire type corresponding to [`RouteRequest`].
12005    #[repr(C)]
12006    pub struct RouteRequest<'de> {
12007        pub(crate) table: ::fidl_next::WireTable<'de>,
12008    }
12009
12010    impl<'de> Drop for RouteRequest<'de> {
12011        fn drop(&mut self) {
12012            let _ = self
12013                .table
12014                .get(1)
12015                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::InstanceToken>() });
12016
12017            let _ = self
12018                .table
12019                .get(2)
12020                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::DictionaryRef>() });
12021        }
12022    }
12023
12024    unsafe impl ::fidl_next::Wire for RouteRequest<'static> {
12025        type Decoded<'de> = RouteRequest<'de>;
12026
12027        #[inline]
12028        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12029            ::fidl_next::munge!(let Self { table } = out);
12030            ::fidl_next::WireTable::zero_padding(table);
12031        }
12032    }
12033
12034    unsafe impl<___D> ::fidl_next::Decode<___D> for RouteRequest<'static>
12035    where
12036        ___D: ::fidl_next::Decoder + ?Sized,
12037        ___D: ::fidl_next::fuchsia::HandleDecoder,
12038    {
12039        fn decode(
12040            slot: ::fidl_next::Slot<'_, Self>,
12041            decoder: &mut ___D,
12042            _: (),
12043        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12044            ::fidl_next::munge!(let Self { table } = slot);
12045
12046            ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
12047                match ordinal {
12048                    0 => unsafe { ::core::hint::unreachable_unchecked() },
12049
12050                    1 => {
12051                        ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::InstanceToken>(
12052                            slot.as_mut(),
12053                            decoder,
12054                            (),
12055                        )?;
12056
12057                        Ok(())
12058                    }
12059
12060                    2 => {
12061                        ::fidl_next::WireEnvelope::decode_as::<___D, crate::wire::DictionaryRef>(
12062                            slot.as_mut(),
12063                            decoder,
12064                            (),
12065                        )?;
12066
12067                        Ok(())
12068                    }
12069
12070                    _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
12071                }
12072            })
12073        }
12074    }
12075
12076    impl<'de> RouteRequest<'de> {
12077        pub fn requesting(&self) -> ::core::option::Option<&crate::wire::InstanceToken> {
12078            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
12079        }
12080
12081        pub fn metadata(&self) -> ::core::option::Option<&crate::wire::DictionaryRef> {
12082            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
12083        }
12084    }
12085
12086    impl<'de> ::core::fmt::Debug for RouteRequest<'de> {
12087        fn fmt(
12088            &self,
12089            f: &mut ::core::fmt::Formatter<'_>,
12090        ) -> ::core::result::Result<(), ::core::fmt::Error> {
12091            f.debug_struct("RouteRequest")
12092                .field("requesting", &self.requesting())
12093                .field("metadata", &self.metadata())
12094                .finish()
12095        }
12096    }
12097
12098    impl<'de> ::fidl_next::IntoNatural for RouteRequest<'de> {
12099        type Natural = crate::natural::RouteRequest;
12100    }
12101
12102    impl ::fidl_next::Unconstrained for RouteRequest<'_> {}
12103
12104    /// The wire type corresponding to [`ConnectorRouterRouteResponse`].
12105    #[repr(transparent)]
12106    pub struct ConnectorRouterRouteResponse {
12107        pub(crate) raw: ::fidl_next::RawWireUnion,
12108        pub(crate) _phantom: ::core::marker::PhantomData<()>,
12109    }
12110
12111    impl Drop for ConnectorRouterRouteResponse {
12112        fn drop(&mut self) {
12113            match self.raw.ordinal() {
12114                1 => {
12115                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Connector>() };
12116                }
12117
12118                2 => {
12119                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
12120                }
12121
12122                _ => unsafe { ::core::hint::unreachable_unchecked() },
12123            }
12124        }
12125    }
12126
12127    unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
12128        type Decoded<'de> = ConnectorRouterRouteResponse;
12129
12130        #[inline]
12131        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12132            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12133            ::fidl_next::RawWireUnion::zero_padding(raw);
12134        }
12135    }
12136
12137    pub mod connector_router_route_response {
12138        pub enum Ref<'de> {
12139            Connector(&'de crate::wire::Connector),
12140
12141            Unavailable(&'de crate::wire::Unit),
12142        }
12143    }
12144
12145    impl ConnectorRouterRouteResponse {
12146        pub fn as_ref(&self) -> crate::wire::connector_router_route_response::Ref<'_> {
12147            match self.raw.ordinal() {
12148                1 => crate::wire::connector_router_route_response::Ref::Connector(unsafe {
12149                    self.raw.get().deref_unchecked::<crate::wire::Connector>()
12150                }),
12151
12152                2 => crate::wire::connector_router_route_response::Ref::Unavailable(unsafe {
12153                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
12154                }),
12155
12156                _ => unsafe { ::core::hint::unreachable_unchecked() },
12157            }
12158        }
12159    }
12160
12161    unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
12162    where
12163        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12164        ___D: ::fidl_next::fuchsia::HandleDecoder,
12165    {
12166        fn decode(
12167            mut slot: ::fidl_next::Slot<'_, Self>,
12168            decoder: &mut ___D,
12169            _: (),
12170        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12171            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12172            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12173                1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
12174                    raw,
12175                    decoder,
12176                    (),
12177                )?,
12178
12179                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
12180                    raw,
12181                    decoder,
12182                    (),
12183                )?,
12184
12185                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12186            }
12187
12188            Ok(())
12189        }
12190    }
12191
12192    impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
12193        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12194            match self.raw.ordinal() {
12195                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Connector>().fmt(f) },
12196                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
12197                _ => unsafe { ::core::hint::unreachable_unchecked() },
12198            }
12199        }
12200    }
12201
12202    impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
12203        type Natural = crate::natural::ConnectorRouterRouteResponse;
12204    }
12205
12206    impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
12207
12208    /// The wire type corresponding to [`RouterError`].
12209    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12210    #[repr(transparent)]
12211    pub struct RouterError {
12212        pub(crate) value: ::fidl_next::WireU32,
12213    }
12214
12215    unsafe impl ::fidl_next::Wire for RouterError {
12216        type Decoded<'de> = Self;
12217
12218        #[inline]
12219        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12220            // Wire enums have no padding
12221        }
12222    }
12223
12224    impl RouterError {
12225        pub const NOT_FOUND: RouterError = RouterError { value: ::fidl_next::WireU32(1) };
12226
12227        pub const INVALID_ARGS: RouterError = RouterError { value: ::fidl_next::WireU32(2) };
12228
12229        pub const NOT_SUPPORTED: RouterError = RouterError { value: ::fidl_next::WireU32(3) };
12230
12231        pub const INTERNAL: RouterError = RouterError { value: ::fidl_next::WireU32(4) };
12232    }
12233
12234    unsafe impl<___D> ::fidl_next::Decode<___D> for RouterError
12235    where
12236        ___D: ?Sized,
12237    {
12238        fn decode(
12239            slot: ::fidl_next::Slot<'_, Self>,
12240            _: &mut ___D,
12241            _: (),
12242        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12243            Ok(())
12244        }
12245    }
12246
12247    impl ::core::convert::From<crate::natural::RouterError> for RouterError {
12248        fn from(natural: crate::natural::RouterError) -> Self {
12249            match natural {
12250                crate::natural::RouterError::NotFound => RouterError::NOT_FOUND,
12251
12252                crate::natural::RouterError::InvalidArgs => RouterError::INVALID_ARGS,
12253
12254                crate::natural::RouterError::NotSupported => RouterError::NOT_SUPPORTED,
12255
12256                crate::natural::RouterError::Internal => RouterError::INTERNAL,
12257
12258                crate::natural::RouterError::UnknownOrdinal_(value) => {
12259                    RouterError { value: ::fidl_next::WireU32::from(value) }
12260                }
12261            }
12262        }
12263    }
12264
12265    impl ::fidl_next::IntoNatural for RouterError {
12266        type Natural = crate::natural::RouterError;
12267    }
12268
12269    impl ::fidl_next::Unconstrained for RouterError {}
12270
12271    /// The wire type corresponding to [`DataRouterRouteResponse`].
12272    #[repr(transparent)]
12273    pub struct DataRouterRouteResponse<'de> {
12274        pub(crate) raw: ::fidl_next::RawWireUnion,
12275        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12276    }
12277
12278    impl<'de> Drop for DataRouterRouteResponse<'de> {
12279        fn drop(&mut self) {
12280            match self.raw.ordinal() {
12281                1 => {
12282                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Data<'de>>() };
12283                }
12284
12285                2 => {
12286                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
12287                }
12288
12289                _ => unsafe { ::core::hint::unreachable_unchecked() },
12290            }
12291        }
12292    }
12293
12294    unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
12295        type Decoded<'de> = DataRouterRouteResponse<'de>;
12296
12297        #[inline]
12298        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12299            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12300            ::fidl_next::RawWireUnion::zero_padding(raw);
12301        }
12302    }
12303
12304    pub mod data_router_route_response {
12305        pub enum Ref<'de> {
12306            Data(&'de crate::wire::Data<'de>),
12307
12308            Unavailable(&'de crate::wire::Unit),
12309        }
12310    }
12311
12312    impl<'de> DataRouterRouteResponse<'de> {
12313        pub fn as_ref(&self) -> crate::wire::data_router_route_response::Ref<'_> {
12314            match self.raw.ordinal() {
12315                1 => crate::wire::data_router_route_response::Ref::Data(unsafe {
12316                    self.raw.get().deref_unchecked::<crate::wire::Data<'_>>()
12317                }),
12318
12319                2 => crate::wire::data_router_route_response::Ref::Unavailable(unsafe {
12320                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
12321                }),
12322
12323                _ => unsafe { ::core::hint::unreachable_unchecked() },
12324            }
12325        }
12326    }
12327
12328    unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
12329    where
12330        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12331        ___D: ::fidl_next::Decoder,
12332        ___D: ::fidl_next::fuchsia::HandleDecoder,
12333    {
12334        fn decode(
12335            mut slot: ::fidl_next::Slot<'_, Self>,
12336            decoder: &mut ___D,
12337            _: (),
12338        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12339            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12340            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
12341                1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
12342                    raw,
12343                    decoder,
12344                    (),
12345                )?,
12346
12347                2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
12348                    raw,
12349                    decoder,
12350                    (),
12351                )?,
12352
12353                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
12354            }
12355
12356            Ok(())
12357        }
12358    }
12359
12360    impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
12361        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12362            match self.raw.ordinal() {
12363                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Data<'_>>().fmt(f) },
12364                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
12365                _ => unsafe { ::core::hint::unreachable_unchecked() },
12366            }
12367        }
12368    }
12369
12370    impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
12371        type Natural = crate::natural::DataRouterRouteResponse;
12372    }
12373
12374    impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
12375
12376    /// The wire type corresponding to [`DictionaryDrainIteratorGetNextRequest`].
12377    #[derive(Clone, Debug)]
12378    #[repr(C)]
12379    pub struct DictionaryDrainIteratorGetNextRequest {
12380        pub start_id: ::fidl_next::WireU64,
12381
12382        pub limit: ::fidl_next::WireU32,
12383    }
12384
12385    static_assertions::const_assert_eq!(
12386        std::mem::size_of::<DictionaryDrainIteratorGetNextRequest>(),
12387        16
12388    );
12389    static_assertions::const_assert_eq!(
12390        std::mem::align_of::<DictionaryDrainIteratorGetNextRequest>(),
12391        8
12392    );
12393
12394    static_assertions::const_assert_eq!(
12395        std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, start_id),
12396        0
12397    );
12398
12399    static_assertions::const_assert_eq!(
12400        std::mem::offset_of!(DictionaryDrainIteratorGetNextRequest, limit),
12401        8
12402    );
12403
12404    unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextRequest {
12405        type Decoded<'de> = DictionaryDrainIteratorGetNextRequest;
12406
12407        #[inline]
12408        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12409            ::fidl_next::munge! {
12410                let Self {
12411
12412                    start_id,
12413                    limit,
12414
12415                } = &mut *out_;
12416            }
12417
12418            ::fidl_next::Wire::zero_padding(start_id);
12419
12420            ::fidl_next::Wire::zero_padding(limit);
12421
12422            unsafe {
12423                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
12424            }
12425        }
12426    }
12427
12428    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextRequest
12429    where
12430        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12431    {
12432        fn decode(
12433            slot_: ::fidl_next::Slot<'_, Self>,
12434            decoder_: &mut ___D,
12435            _: (),
12436        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12437            if slot_.as_bytes()[12..16] != [0u8; 4] {
12438                return Err(::fidl_next::DecodeError::InvalidPadding);
12439            }
12440
12441            ::fidl_next::munge! {
12442                let Self {
12443
12444                    mut start_id,
12445                    mut limit,
12446
12447                } = slot_;
12448            }
12449
12450            let _field = start_id.as_mut();
12451
12452            ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
12453
12454            let _field = limit.as_mut();
12455
12456            ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
12457
12458            Ok(())
12459        }
12460    }
12461
12462    impl ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextRequest {
12463        type Natural = crate::natural::DictionaryDrainIteratorGetNextRequest;
12464    }
12465
12466    impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextRequest {}
12467
12468    /// The wire type corresponding to [`DictionaryDrainIteratorGetNextResponse`].
12469    #[derive(Debug)]
12470    #[repr(C)]
12471    pub struct DictionaryDrainIteratorGetNextResponse<'de> {
12472        pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryItem<'de>>,
12473
12474        pub end_id: ::fidl_next::WireU64,
12475    }
12476
12477    static_assertions::const_assert_eq!(
12478        std::mem::size_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
12479        24
12480    );
12481    static_assertions::const_assert_eq!(
12482        std::mem::align_of::<DictionaryDrainIteratorGetNextResponse<'_>>(),
12483        8
12484    );
12485
12486    static_assertions::const_assert_eq!(
12487        std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, items),
12488        0
12489    );
12490
12491    static_assertions::const_assert_eq!(
12492        std::mem::offset_of!(DictionaryDrainIteratorGetNextResponse<'_>, end_id),
12493        16
12494    );
12495
12496    unsafe impl ::fidl_next::Wire for DictionaryDrainIteratorGetNextResponse<'static> {
12497        type Decoded<'de> = DictionaryDrainIteratorGetNextResponse<'de>;
12498
12499        #[inline]
12500        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12501            ::fidl_next::munge! {
12502                let Self {
12503
12504                    items,
12505                    end_id,
12506
12507                } = &mut *out_;
12508            }
12509
12510            ::fidl_next::Wire::zero_padding(items);
12511
12512            ::fidl_next::Wire::zero_padding(end_id);
12513        }
12514    }
12515
12516    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryDrainIteratorGetNextResponse<'static>
12517    where
12518        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12519        ___D: ::fidl_next::Decoder,
12520        ___D: ::fidl_next::fuchsia::HandleDecoder,
12521    {
12522        fn decode(
12523            slot_: ::fidl_next::Slot<'_, Self>,
12524            decoder_: &mut ___D,
12525            _: (),
12526        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12527            ::fidl_next::munge! {
12528                let Self {
12529
12530                    mut items,
12531                    mut end_id,
12532
12533                } = slot_;
12534            }
12535
12536            let _field = items.as_mut();
12537            ::fidl_next::Constrained::validate(_field, (128, ()))?;
12538            ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
12539
12540            let items = unsafe { items.deref_unchecked() };
12541
12542            if items.len() > 128 {
12543                return Err(::fidl_next::DecodeError::VectorTooLong {
12544                    size: items.len() as u64,
12545                    limit: 128,
12546                });
12547            }
12548
12549            let _field = end_id.as_mut();
12550
12551            ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
12552
12553            Ok(())
12554        }
12555    }
12556
12557    impl<'de> ::fidl_next::IntoNatural for DictionaryDrainIteratorGetNextResponse<'de> {
12558        type Natural = crate::natural::DictionaryDrainIteratorGetNextResponse;
12559    }
12560
12561    impl ::fidl_next::Unconstrained for DictionaryDrainIteratorGetNextResponse<'static> {}
12562
12563    /// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextRequest`].
12564    #[derive(Clone, Debug)]
12565    #[repr(C)]
12566    pub struct DictionaryEnumerateIteratorGetNextRequest {
12567        pub start_id: ::fidl_next::WireU64,
12568
12569        pub limit: ::fidl_next::WireU32,
12570    }
12571
12572    static_assertions::const_assert_eq!(
12573        std::mem::size_of::<DictionaryEnumerateIteratorGetNextRequest>(),
12574        16
12575    );
12576    static_assertions::const_assert_eq!(
12577        std::mem::align_of::<DictionaryEnumerateIteratorGetNextRequest>(),
12578        8
12579    );
12580
12581    static_assertions::const_assert_eq!(
12582        std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, start_id),
12583        0
12584    );
12585
12586    static_assertions::const_assert_eq!(
12587        std::mem::offset_of!(DictionaryEnumerateIteratorGetNextRequest, limit),
12588        8
12589    );
12590
12591    unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextRequest {
12592        type Decoded<'de> = DictionaryEnumerateIteratorGetNextRequest;
12593
12594        #[inline]
12595        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12596            ::fidl_next::munge! {
12597                let Self {
12598
12599                    start_id,
12600                    limit,
12601
12602                } = &mut *out_;
12603            }
12604
12605            ::fidl_next::Wire::zero_padding(start_id);
12606
12607            ::fidl_next::Wire::zero_padding(limit);
12608
12609            unsafe {
12610                out_.as_mut_ptr().cast::<u8>().add(12).write_bytes(0, 4);
12611            }
12612        }
12613    }
12614
12615    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextRequest
12616    where
12617        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12618    {
12619        fn decode(
12620            slot_: ::fidl_next::Slot<'_, Self>,
12621            decoder_: &mut ___D,
12622            _: (),
12623        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12624            if slot_.as_bytes()[12..16] != [0u8; 4] {
12625                return Err(::fidl_next::DecodeError::InvalidPadding);
12626            }
12627
12628            ::fidl_next::munge! {
12629                let Self {
12630
12631                    mut start_id,
12632                    mut limit,
12633
12634                } = slot_;
12635            }
12636
12637            let _field = start_id.as_mut();
12638
12639            ::fidl_next::Decode::decode(start_id.as_mut(), decoder_, ())?;
12640
12641            let _field = limit.as_mut();
12642
12643            ::fidl_next::Decode::decode(limit.as_mut(), decoder_, ())?;
12644
12645            Ok(())
12646        }
12647    }
12648
12649    impl ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextRequest {
12650        type Natural = crate::natural::DictionaryEnumerateIteratorGetNextRequest;
12651    }
12652
12653    impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextRequest {}
12654
12655    /// The wire type corresponding to [`DictionaryOptionalItem`].
12656    #[derive(Debug)]
12657    #[repr(C)]
12658    pub struct DictionaryOptionalItem<'de> {
12659        pub key: ::fidl_next::WireString<'de>,
12660
12661        pub value: ::fidl_next::WireBox<'de, crate::wire::WrappedCapabilityId>,
12662    }
12663
12664    static_assertions::const_assert_eq!(std::mem::size_of::<DictionaryOptionalItem<'_>>(), 24);
12665    static_assertions::const_assert_eq!(std::mem::align_of::<DictionaryOptionalItem<'_>>(), 8);
12666
12667    static_assertions::const_assert_eq!(std::mem::offset_of!(DictionaryOptionalItem<'_>, key), 0);
12668
12669    static_assertions::const_assert_eq!(
12670        std::mem::offset_of!(DictionaryOptionalItem<'_>, value),
12671        16
12672    );
12673
12674    unsafe impl ::fidl_next::Wire for DictionaryOptionalItem<'static> {
12675        type Decoded<'de> = DictionaryOptionalItem<'de>;
12676
12677        #[inline]
12678        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12679            ::fidl_next::munge! {
12680                let Self {
12681
12682                    key,
12683                    value,
12684
12685                } = &mut *out_;
12686            }
12687
12688            ::fidl_next::Wire::zero_padding(key);
12689
12690            ::fidl_next::Wire::zero_padding(value);
12691        }
12692    }
12693
12694    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryOptionalItem<'static>
12695    where
12696        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12697        ___D: ::fidl_next::Decoder,
12698        ___D: ::fidl_next::fuchsia::HandleDecoder,
12699    {
12700        fn decode(
12701            slot_: ::fidl_next::Slot<'_, Self>,
12702            decoder_: &mut ___D,
12703            _: (),
12704        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12705            ::fidl_next::munge! {
12706                let Self {
12707
12708                    mut key,
12709                    mut value,
12710
12711                } = slot_;
12712            }
12713
12714            let _field = key.as_mut();
12715            ::fidl_next::Constrained::validate(_field, 255)?;
12716            ::fidl_next::Decode::decode(key.as_mut(), decoder_, 255)?;
12717
12718            let key = unsafe { key.deref_unchecked() };
12719
12720            if key.len() > 255 {
12721                return Err(::fidl_next::DecodeError::VectorTooLong {
12722                    size: key.len() as u64,
12723                    limit: 255,
12724                });
12725            }
12726
12727            let _field = value.as_mut();
12728
12729            ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
12730
12731            Ok(())
12732        }
12733    }
12734
12735    impl<'de> ::fidl_next::IntoNatural for DictionaryOptionalItem<'de> {
12736        type Natural = crate::natural::DictionaryOptionalItem;
12737    }
12738
12739    impl ::fidl_next::Unconstrained for DictionaryOptionalItem<'static> {}
12740
12741    /// The wire type corresponding to [`DictionaryEnumerateIteratorGetNextResponse`].
12742    #[derive(Debug)]
12743    #[repr(C)]
12744    pub struct DictionaryEnumerateIteratorGetNextResponse<'de> {
12745        pub items: ::fidl_next::WireVector<'de, crate::wire::DictionaryOptionalItem<'de>>,
12746
12747        pub end_id: ::fidl_next::WireU64,
12748    }
12749
12750    static_assertions::const_assert_eq!(
12751        std::mem::size_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
12752        24
12753    );
12754    static_assertions::const_assert_eq!(
12755        std::mem::align_of::<DictionaryEnumerateIteratorGetNextResponse<'_>>(),
12756        8
12757    );
12758
12759    static_assertions::const_assert_eq!(
12760        std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, items),
12761        0
12762    );
12763
12764    static_assertions::const_assert_eq!(
12765        std::mem::offset_of!(DictionaryEnumerateIteratorGetNextResponse<'_>, end_id),
12766        16
12767    );
12768
12769    unsafe impl ::fidl_next::Wire for DictionaryEnumerateIteratorGetNextResponse<'static> {
12770        type Decoded<'de> = DictionaryEnumerateIteratorGetNextResponse<'de>;
12771
12772        #[inline]
12773        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12774            ::fidl_next::munge! {
12775                let Self {
12776
12777                    items,
12778                    end_id,
12779
12780                } = &mut *out_;
12781            }
12782
12783            ::fidl_next::Wire::zero_padding(items);
12784
12785            ::fidl_next::Wire::zero_padding(end_id);
12786        }
12787    }
12788
12789    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryEnumerateIteratorGetNextResponse<'static>
12790    where
12791        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12792        ___D: ::fidl_next::Decoder,
12793        ___D: ::fidl_next::fuchsia::HandleDecoder,
12794    {
12795        fn decode(
12796            slot_: ::fidl_next::Slot<'_, Self>,
12797            decoder_: &mut ___D,
12798            _: (),
12799        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12800            ::fidl_next::munge! {
12801                let Self {
12802
12803                    mut items,
12804                    mut end_id,
12805
12806                } = slot_;
12807            }
12808
12809            let _field = items.as_mut();
12810            ::fidl_next::Constrained::validate(_field, (128, ()))?;
12811            ::fidl_next::Decode::decode(items.as_mut(), decoder_, (128, ()))?;
12812
12813            let items = unsafe { items.deref_unchecked() };
12814
12815            if items.len() > 128 {
12816                return Err(::fidl_next::DecodeError::VectorTooLong {
12817                    size: items.len() as u64,
12818                    limit: 128,
12819                });
12820            }
12821
12822            let _field = end_id.as_mut();
12823
12824            ::fidl_next::Decode::decode(end_id.as_mut(), decoder_, ())?;
12825
12826            Ok(())
12827        }
12828    }
12829
12830    impl<'de> ::fidl_next::IntoNatural for DictionaryEnumerateIteratorGetNextResponse<'de> {
12831        type Natural = crate::natural::DictionaryEnumerateIteratorGetNextResponse;
12832    }
12833
12834    impl ::fidl_next::Unconstrained for DictionaryEnumerateIteratorGetNextResponse<'static> {}
12835
12836    /// The wire type corresponding to [`DictionaryError`].
12837    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12838    #[repr(transparent)]
12839    pub struct DictionaryError {
12840        pub(crate) value: ::fidl_next::WireU32,
12841    }
12842
12843    unsafe impl ::fidl_next::Wire for DictionaryError {
12844        type Decoded<'de> = Self;
12845
12846        #[inline]
12847        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12848            // Wire enums have no padding
12849        }
12850    }
12851
12852    impl DictionaryError {
12853        pub const NOT_FOUND: DictionaryError = DictionaryError { value: ::fidl_next::WireU32(1) };
12854
12855        pub const ALREADY_EXISTS: DictionaryError =
12856            DictionaryError { value: ::fidl_next::WireU32(2) };
12857
12858        pub const BAD_CAPABILITY: DictionaryError =
12859            DictionaryError { value: ::fidl_next::WireU32(3) };
12860
12861        pub const INVALID_KEY: DictionaryError = DictionaryError { value: ::fidl_next::WireU32(4) };
12862
12863        pub const NOT_CLONEABLE: DictionaryError =
12864            DictionaryError { value: ::fidl_next::WireU32(5) };
12865    }
12866
12867    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryError
12868    where
12869        ___D: ?Sized,
12870    {
12871        fn decode(
12872            slot: ::fidl_next::Slot<'_, Self>,
12873            _: &mut ___D,
12874            _: (),
12875        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12876            Ok(())
12877        }
12878    }
12879
12880    impl ::core::convert::From<crate::natural::DictionaryError> for DictionaryError {
12881        fn from(natural: crate::natural::DictionaryError) -> Self {
12882            match natural {
12883                crate::natural::DictionaryError::NotFound => DictionaryError::NOT_FOUND,
12884
12885                crate::natural::DictionaryError::AlreadyExists => DictionaryError::ALREADY_EXISTS,
12886
12887                crate::natural::DictionaryError::BadCapability => DictionaryError::BAD_CAPABILITY,
12888
12889                crate::natural::DictionaryError::InvalidKey => DictionaryError::INVALID_KEY,
12890
12891                crate::natural::DictionaryError::NotCloneable => DictionaryError::NOT_CLONEABLE,
12892
12893                crate::natural::DictionaryError::UnknownOrdinal_(value) => {
12894                    DictionaryError { value: ::fidl_next::WireU32::from(value) }
12895                }
12896            }
12897        }
12898    }
12899
12900    impl ::fidl_next::IntoNatural for DictionaryError {
12901        type Natural = crate::natural::DictionaryError;
12902    }
12903
12904    impl ::fidl_next::Unconstrained for DictionaryError {}
12905
12906    /// The wire type corresponding to [`DictionaryKeysIteratorGetNextResponse`].
12907    #[derive(Debug)]
12908    #[repr(C)]
12909    pub struct DictionaryKeysIteratorGetNextResponse<'de> {
12910        pub keys: ::fidl_next::WireVector<'de, ::fidl_next::WireString<'de>>,
12911    }
12912
12913    static_assertions::const_assert_eq!(
12914        std::mem::size_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
12915        16
12916    );
12917    static_assertions::const_assert_eq!(
12918        std::mem::align_of::<DictionaryKeysIteratorGetNextResponse<'_>>(),
12919        8
12920    );
12921
12922    static_assertions::const_assert_eq!(
12923        std::mem::offset_of!(DictionaryKeysIteratorGetNextResponse<'_>, keys),
12924        0
12925    );
12926
12927    unsafe impl ::fidl_next::Wire for DictionaryKeysIteratorGetNextResponse<'static> {
12928        type Decoded<'de> = DictionaryKeysIteratorGetNextResponse<'de>;
12929
12930        #[inline]
12931        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12932            ::fidl_next::munge! {
12933                let Self {
12934
12935                    keys,
12936
12937                } = &mut *out_;
12938            }
12939
12940            ::fidl_next::Wire::zero_padding(keys);
12941        }
12942    }
12943
12944    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryKeysIteratorGetNextResponse<'static>
12945    where
12946        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12947        ___D: ::fidl_next::Decoder,
12948        ___D: ::fidl_next::fuchsia::HandleDecoder,
12949    {
12950        fn decode(
12951            slot_: ::fidl_next::Slot<'_, Self>,
12952            decoder_: &mut ___D,
12953            _: (),
12954        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12955            ::fidl_next::munge! {
12956                let Self {
12957
12958                    mut keys,
12959
12960                } = slot_;
12961            }
12962
12963            let _field = keys.as_mut();
12964            ::fidl_next::Constrained::validate(_field, (128, 255))?;
12965            ::fidl_next::Decode::decode(keys.as_mut(), decoder_, (128, 255))?;
12966
12967            let keys = unsafe { keys.deref_unchecked() };
12968
12969            if keys.len() > 128 {
12970                return Err(::fidl_next::DecodeError::VectorTooLong {
12971                    size: keys.len() as u64,
12972                    limit: 128,
12973                });
12974            }
12975
12976            Ok(())
12977        }
12978    }
12979
12980    impl<'de> ::fidl_next::IntoNatural for DictionaryKeysIteratorGetNextResponse<'de> {
12981        type Natural = crate::natural::DictionaryKeysIteratorGetNextResponse;
12982    }
12983
12984    impl ::fidl_next::Unconstrained for DictionaryKeysIteratorGetNextResponse<'static> {}
12985
12986    /// The wire type corresponding to [`DictionaryRouterRouteResponse`].
12987    #[repr(transparent)]
12988    pub struct DictionaryRouterRouteResponse {
12989        pub(crate) raw: ::fidl_next::RawWireUnion,
12990        pub(crate) _phantom: ::core::marker::PhantomData<()>,
12991    }
12992
12993    impl Drop for DictionaryRouterRouteResponse {
12994        fn drop(&mut self) {
12995            match self.raw.ordinal() {
12996                1 => {
12997                    let _ =
12998                        unsafe { self.raw.get().read_unchecked::<crate::wire::DictionaryRef>() };
12999                }
13000
13001                2 => {
13002                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13003                }
13004
13005                _ => unsafe { ::core::hint::unreachable_unchecked() },
13006            }
13007        }
13008    }
13009
13010    unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
13011        type Decoded<'de> = DictionaryRouterRouteResponse;
13012
13013        #[inline]
13014        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13015            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13016            ::fidl_next::RawWireUnion::zero_padding(raw);
13017        }
13018    }
13019
13020    pub mod dictionary_router_route_response {
13021        pub enum Ref<'de> {
13022            Dictionary(&'de crate::wire::DictionaryRef),
13023
13024            Unavailable(&'de crate::wire::Unit),
13025        }
13026    }
13027
13028    impl DictionaryRouterRouteResponse {
13029        pub fn as_ref(&self) -> crate::wire::dictionary_router_route_response::Ref<'_> {
13030            match self.raw.ordinal() {
13031                1 => crate::wire::dictionary_router_route_response::Ref::Dictionary(unsafe {
13032                    self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>()
13033                }),
13034
13035                2 => crate::wire::dictionary_router_route_response::Ref::Unavailable(unsafe {
13036                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
13037                }),
13038
13039                _ => unsafe { ::core::hint::unreachable_unchecked() },
13040            }
13041        }
13042    }
13043
13044    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
13045    where
13046        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13047        ___D: ::fidl_next::fuchsia::HandleDecoder,
13048    {
13049        fn decode(
13050            mut slot: ::fidl_next::Slot<'_, Self>,
13051            decoder: &mut ___D,
13052            _: (),
13053        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13054            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13055            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13056                1 => {
13057                    ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
13058                        raw,
13059                        decoder,
13060                        (),
13061                    )?
13062                }
13063
13064                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13065                    raw,
13066                    decoder,
13067                    (),
13068                )?,
13069
13070                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13071            }
13072
13073            Ok(())
13074        }
13075    }
13076
13077    impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
13078        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13079            match self.raw.ordinal() {
13080                1 => unsafe {
13081                    self.raw.get().deref_unchecked::<crate::wire::DictionaryRef>().fmt(f)
13082                },
13083                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13084                _ => unsafe { ::core::hint::unreachable_unchecked() },
13085            }
13086        }
13087    }
13088
13089    impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
13090        type Natural = crate::natural::DictionaryRouterRouteResponse;
13091    }
13092
13093    impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
13094
13095    /// The wire type corresponding to [`DirConnectorRouterRouteResponse`].
13096    #[repr(transparent)]
13097    pub struct DirConnectorRouterRouteResponse {
13098        pub(crate) raw: ::fidl_next::RawWireUnion,
13099        pub(crate) _phantom: ::core::marker::PhantomData<()>,
13100    }
13101
13102    impl Drop for DirConnectorRouterRouteResponse {
13103        fn drop(&mut self) {
13104            match self.raw.ordinal() {
13105                1 => {
13106                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirConnector>() };
13107                }
13108
13109                2 => {
13110                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13111                }
13112
13113                _ => unsafe { ::core::hint::unreachable_unchecked() },
13114            }
13115        }
13116    }
13117
13118    unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
13119        type Decoded<'de> = DirConnectorRouterRouteResponse;
13120
13121        #[inline]
13122        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13123            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13124            ::fidl_next::RawWireUnion::zero_padding(raw);
13125        }
13126    }
13127
13128    pub mod dir_connector_router_route_response {
13129        pub enum Ref<'de> {
13130            DirConnector(&'de crate::wire::DirConnector),
13131
13132            Unavailable(&'de crate::wire::Unit),
13133        }
13134    }
13135
13136    impl DirConnectorRouterRouteResponse {
13137        pub fn as_ref(&self) -> crate::wire::dir_connector_router_route_response::Ref<'_> {
13138            match self.raw.ordinal() {
13139                1 => crate::wire::dir_connector_router_route_response::Ref::DirConnector(unsafe {
13140                    self.raw.get().deref_unchecked::<crate::wire::DirConnector>()
13141                }),
13142
13143                2 => crate::wire::dir_connector_router_route_response::Ref::Unavailable(unsafe {
13144                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
13145                }),
13146
13147                _ => unsafe { ::core::hint::unreachable_unchecked() },
13148            }
13149        }
13150    }
13151
13152    unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
13153    where
13154        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13155        ___D: ::fidl_next::fuchsia::HandleDecoder,
13156    {
13157        fn decode(
13158            mut slot: ::fidl_next::Slot<'_, Self>,
13159            decoder: &mut ___D,
13160            _: (),
13161        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13162            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13163            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13164                1 => {
13165                    ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
13166                        raw,
13167                        decoder,
13168                        (),
13169                    )?
13170                }
13171
13172                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13173                    raw,
13174                    decoder,
13175                    (),
13176                )?,
13177
13178                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13179            }
13180
13181            Ok(())
13182        }
13183    }
13184
13185    impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
13186        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13187            match self.raw.ordinal() {
13188                1 => unsafe {
13189                    self.raw.get().deref_unchecked::<crate::wire::DirConnector>().fmt(f)
13190                },
13191                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13192                _ => unsafe { ::core::hint::unreachable_unchecked() },
13193            }
13194        }
13195    }
13196
13197    impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
13198        type Natural = crate::natural::DirConnectorRouterRouteResponse;
13199    }
13200
13201    impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
13202
13203    /// The wire type corresponding to [`DirEntryRouterRouteResponse`].
13204    #[repr(transparent)]
13205    pub struct DirEntryRouterRouteResponse {
13206        pub(crate) raw: ::fidl_next::RawWireUnion,
13207        pub(crate) _phantom: ::core::marker::PhantomData<()>,
13208    }
13209
13210    impl Drop for DirEntryRouterRouteResponse {
13211        fn drop(&mut self) {
13212            match self.raw.ordinal() {
13213                1 => {
13214                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::DirEntry>() };
13215                }
13216
13217                2 => {
13218                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13219                }
13220
13221                _ => unsafe { ::core::hint::unreachable_unchecked() },
13222            }
13223        }
13224    }
13225
13226    unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
13227        type Decoded<'de> = DirEntryRouterRouteResponse;
13228
13229        #[inline]
13230        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13231            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13232            ::fidl_next::RawWireUnion::zero_padding(raw);
13233        }
13234    }
13235
13236    pub mod dir_entry_router_route_response {
13237        pub enum Ref<'de> {
13238            DirEntry(&'de crate::wire::DirEntry),
13239
13240            Unavailable(&'de crate::wire::Unit),
13241        }
13242    }
13243
13244    impl DirEntryRouterRouteResponse {
13245        pub fn as_ref(&self) -> crate::wire::dir_entry_router_route_response::Ref<'_> {
13246            match self.raw.ordinal() {
13247                1 => crate::wire::dir_entry_router_route_response::Ref::DirEntry(unsafe {
13248                    self.raw.get().deref_unchecked::<crate::wire::DirEntry>()
13249                }),
13250
13251                2 => crate::wire::dir_entry_router_route_response::Ref::Unavailable(unsafe {
13252                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
13253                }),
13254
13255                _ => unsafe { ::core::hint::unreachable_unchecked() },
13256            }
13257        }
13258    }
13259
13260    unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
13261    where
13262        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13263        ___D: ::fidl_next::fuchsia::HandleDecoder,
13264    {
13265        fn decode(
13266            mut slot: ::fidl_next::Slot<'_, Self>,
13267            decoder: &mut ___D,
13268            _: (),
13269        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13270            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13271            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13272                1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
13273                    raw,
13274                    decoder,
13275                    (),
13276                )?,
13277
13278                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13279                    raw,
13280                    decoder,
13281                    (),
13282                )?,
13283
13284                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13285            }
13286
13287            Ok(())
13288        }
13289    }
13290
13291    impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
13292        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13293            match self.raw.ordinal() {
13294                1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::DirEntry>().fmt(f) },
13295                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13296                _ => unsafe { ::core::hint::unreachable_unchecked() },
13297            }
13298        }
13299    }
13300
13301    impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
13302        type Natural = crate::natural::DirEntryRouterRouteResponse;
13303    }
13304
13305    impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
13306
13307    /// The wire type corresponding to [`DirReceiverReceiveRequest`].
13308    #[derive(Debug)]
13309    #[repr(C)]
13310    pub struct DirReceiverReceiveRequest {
13311        pub channel: ::fidl_next::ServerEnd<
13312            ::fidl_next_fuchsia_io::Directory,
13313            ::fidl_next::fuchsia::WireChannel,
13314        >,
13315    }
13316
13317    static_assertions::const_assert_eq!(std::mem::size_of::<DirReceiverReceiveRequest>(), 4);
13318    static_assertions::const_assert_eq!(std::mem::align_of::<DirReceiverReceiveRequest>(), 4);
13319
13320    static_assertions::const_assert_eq!(
13321        std::mem::offset_of!(DirReceiverReceiveRequest, channel),
13322        0
13323    );
13324
13325    unsafe impl ::fidl_next::Wire for DirReceiverReceiveRequest {
13326        type Decoded<'de> = DirReceiverReceiveRequest;
13327
13328        #[inline]
13329        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13330            ::fidl_next::munge! {
13331                let Self {
13332
13333                    channel,
13334
13335                } = &mut *out_;
13336            }
13337
13338            ::fidl_next::Wire::zero_padding(channel);
13339        }
13340    }
13341
13342    unsafe impl<___D> ::fidl_next::Decode<___D> for DirReceiverReceiveRequest
13343    where
13344        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13345        ___D: ::fidl_next::fuchsia::HandleDecoder,
13346    {
13347        fn decode(
13348            slot_: ::fidl_next::Slot<'_, Self>,
13349            decoder_: &mut ___D,
13350            _: (),
13351        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13352            ::fidl_next::munge! {
13353                let Self {
13354
13355                    mut channel,
13356
13357                } = slot_;
13358            }
13359
13360            let _field = channel.as_mut();
13361
13362            ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
13363
13364            Ok(())
13365        }
13366    }
13367
13368    impl ::fidl_next::IntoNatural for DirReceiverReceiveRequest {
13369        type Natural = crate::natural::DirReceiverReceiveRequest;
13370    }
13371
13372    impl ::fidl_next::Unconstrained for DirReceiverReceiveRequest {}
13373
13374    /// The wire type corresponding to [`DirectoryRouterRouteResponse`].
13375    #[repr(transparent)]
13376    pub struct DirectoryRouterRouteResponse {
13377        pub(crate) raw: ::fidl_next::RawWireUnion,
13378        pub(crate) _phantom: ::core::marker::PhantomData<()>,
13379    }
13380
13381    impl Drop for DirectoryRouterRouteResponse {
13382        fn drop(&mut self) {
13383            match self.raw.ordinal() {
13384                1 => {
13385                    let _ = unsafe {
13386                        self.raw.get().read_unchecked::<::fidl_next::ClientEnd<
13387                            ::fidl_next_fuchsia_io::Directory,
13388                            ::fidl_next::fuchsia::WireChannel,
13389                        >>()
13390                    };
13391                }
13392
13393                2 => {
13394                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Unit>() };
13395                }
13396
13397                _ => unsafe { ::core::hint::unreachable_unchecked() },
13398            }
13399        }
13400    }
13401
13402    unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
13403        type Decoded<'de> = DirectoryRouterRouteResponse;
13404
13405        #[inline]
13406        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13407            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13408            ::fidl_next::RawWireUnion::zero_padding(raw);
13409        }
13410    }
13411
13412    pub mod directory_router_route_response {
13413        pub enum Ref<'de> {
13414            Directory(
13415                &'de ::fidl_next::ClientEnd<
13416                    ::fidl_next_fuchsia_io::Directory,
13417                    ::fidl_next::fuchsia::WireChannel,
13418                >,
13419            ),
13420
13421            Unavailable(&'de crate::wire::Unit),
13422        }
13423    }
13424
13425    impl DirectoryRouterRouteResponse {
13426        pub fn as_ref(&self) -> crate::wire::directory_router_route_response::Ref<'_> {
13427            match self.raw.ordinal() {
13428                1 => crate::wire::directory_router_route_response::Ref::Directory(unsafe {
13429                    self.raw.get().deref_unchecked::<::fidl_next::ClientEnd<
13430                        ::fidl_next_fuchsia_io::Directory,
13431                        ::fidl_next::fuchsia::WireChannel,
13432                    >>()
13433                }),
13434
13435                2 => crate::wire::directory_router_route_response::Ref::Unavailable(unsafe {
13436                    self.raw.get().deref_unchecked::<crate::wire::Unit>()
13437                }),
13438
13439                _ => unsafe { ::core::hint::unreachable_unchecked() },
13440            }
13441        }
13442    }
13443
13444    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
13445    where
13446        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13447        ___D: ::fidl_next::fuchsia::HandleDecoder,
13448    {
13449        fn decode(
13450            mut slot: ::fidl_next::Slot<'_, Self>,
13451            decoder: &mut ___D,
13452            _: (),
13453        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13454            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13455            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13456                1 => ::fidl_next::RawWireUnion::decode_as_static::<
13457                    ___D,
13458                    ::fidl_next::ClientEnd<
13459                        ::fidl_next_fuchsia_io::Directory,
13460                        ::fidl_next::fuchsia::WireChannel,
13461                    >,
13462                >(raw, decoder, ())?,
13463
13464                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13465                    raw,
13466                    decoder,
13467                    (),
13468                )?,
13469
13470                ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
13471            }
13472
13473            Ok(())
13474        }
13475    }
13476
13477    impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
13478        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13479            match self.raw.ordinal() {
13480                1 => unsafe {
13481                    self.raw
13482                        .get()
13483                        .deref_unchecked::<::fidl_next::ClientEnd<
13484                            ::fidl_next_fuchsia_io::Directory,
13485                            ::fidl_next::fuchsia::WireChannel,
13486                        >>()
13487                        .fmt(f)
13488                },
13489                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Unit>().fmt(f) },
13490                _ => unsafe { ::core::hint::unreachable_unchecked() },
13491            }
13492        }
13493    }
13494
13495    impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
13496        type Natural = crate::natural::DirectoryRouterRouteResponse;
13497    }
13498
13499    impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
13500
13501    /// The wire type corresponding to [`ProtocolPayload`].
13502    #[derive(Debug)]
13503    #[repr(C)]
13504    pub struct ProtocolPayload {
13505        pub channel: ::fidl_next::fuchsia::WireChannel,
13506    }
13507
13508    static_assertions::const_assert_eq!(std::mem::size_of::<ProtocolPayload>(), 4);
13509    static_assertions::const_assert_eq!(std::mem::align_of::<ProtocolPayload>(), 4);
13510
13511    static_assertions::const_assert_eq!(std::mem::offset_of!(ProtocolPayload, channel), 0);
13512
13513    unsafe impl ::fidl_next::Wire for ProtocolPayload {
13514        type Decoded<'de> = ProtocolPayload;
13515
13516        #[inline]
13517        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13518            ::fidl_next::munge! {
13519                let Self {
13520
13521                    channel,
13522
13523                } = &mut *out_;
13524            }
13525
13526            ::fidl_next::Wire::zero_padding(channel);
13527        }
13528    }
13529
13530    unsafe impl<___D> ::fidl_next::Decode<___D> for ProtocolPayload
13531    where
13532        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13533        ___D: ::fidl_next::fuchsia::HandleDecoder,
13534    {
13535        fn decode(
13536            slot_: ::fidl_next::Slot<'_, Self>,
13537            decoder_: &mut ___D,
13538            _: (),
13539        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13540            ::fidl_next::munge! {
13541                let Self {
13542
13543                    mut channel,
13544
13545                } = slot_;
13546            }
13547
13548            let _field = channel.as_mut();
13549
13550            ::fidl_next::Decode::decode(channel.as_mut(), decoder_, ())?;
13551
13552            Ok(())
13553        }
13554    }
13555
13556    impl ::fidl_next::IntoNatural for ProtocolPayload {
13557        type Natural = crate::natural::ProtocolPayload;
13558    }
13559
13560    impl ::fidl_next::Unconstrained for ProtocolPayload {}
13561
13562    /// The wire type corresponding to [`Unavailable`].
13563    #[derive(Clone, Debug)]
13564    #[repr(C)]
13565    pub struct Unavailable {
13566        pub(crate) _empty: fidl_next::WireEmptyStructPlaceholder,
13567    }
13568
13569    static_assertions::const_assert_eq!(std::mem::size_of::<Unavailable>(), 1);
13570    static_assertions::const_assert_eq!(std::mem::align_of::<Unavailable>(), 1);
13571
13572    unsafe impl ::fidl_next::Wire for Unavailable {
13573        type Decoded<'de> = Unavailable;
13574
13575        #[inline]
13576        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13577            ::fidl_next::munge! {
13578                let Self {
13579
13580                        _empty,
13581
13582
13583                } = &mut *out_;
13584            }
13585        }
13586    }
13587
13588    unsafe impl<___D> ::fidl_next::Decode<___D> for Unavailable
13589    where
13590        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13591    {
13592        fn decode(
13593            slot_: ::fidl_next::Slot<'_, Self>,
13594            decoder_: &mut ___D,
13595            _: (),
13596        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13597            ::fidl_next::munge! {
13598                let Self {
13599
13600                        mut _empty,
13601
13602
13603                } = slot_;
13604            }
13605
13606            if _empty.as_bytes() != &[0u8] {
13607                return Err(::fidl_next::DecodeError::InvalidEmptyStruct);
13608            }
13609
13610            Ok(())
13611        }
13612    }
13613
13614    impl ::fidl_next::IntoNatural for Unavailable {
13615        type Natural = crate::natural::Unavailable;
13616    }
13617
13618    impl ::fidl_next::Unconstrained for Unavailable {}
13619}
13620
13621pub mod wire_optional {
13622
13623    #[repr(transparent)]
13624    pub struct Data<'de> {
13625        pub(crate) raw: ::fidl_next::RawWireUnion,
13626        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13627    }
13628
13629    unsafe impl ::fidl_next::Wire for Data<'static> {
13630        type Decoded<'de> = Data<'de>;
13631
13632        #[inline]
13633        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13634            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13635            ::fidl_next::RawWireUnion::zero_padding(raw);
13636        }
13637    }
13638
13639    impl<'de> Data<'de> {
13640        pub fn is_some(&self) -> bool {
13641            self.raw.is_some()
13642        }
13643
13644        pub fn is_none(&self) -> bool {
13645            self.raw.is_none()
13646        }
13647
13648        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Data<'de>> {
13649            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13650        }
13651
13652        pub fn into_option(self) -> ::core::option::Option<crate::wire::Data<'de>> {
13653            if self.is_some() {
13654                Some(crate::wire::Data { raw: self.raw, _phantom: ::core::marker::PhantomData })
13655            } else {
13656                None
13657            }
13658        }
13659    }
13660
13661    unsafe impl<___D> ::fidl_next::Decode<___D> for Data<'static>
13662    where
13663        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13664        ___D: ::fidl_next::Decoder,
13665    {
13666        fn decode(
13667            mut slot: ::fidl_next::Slot<'_, Self>,
13668            decoder: &mut ___D,
13669            _: (),
13670        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13671            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13672            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13673                1 => ::fidl_next::RawWireUnion::decode_as::<
13674                    ___D,
13675                    ::fidl_next::WireVector<'static, u8>,
13676                >(raw, decoder, (8192, ()))?,
13677
13678                2 => {
13679                    ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireString<'static>>(
13680                        raw, decoder, 8192,
13681                    )?
13682                }
13683
13684                3 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireI64>(
13685                    raw,
13686                    decoder,
13687                    (),
13688                )?,
13689
13690                4 => ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::WireU64>(
13691                    raw,
13692                    decoder,
13693                    (),
13694                )?,
13695
13696                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13697                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
13698            }
13699
13700            Ok(())
13701        }
13702    }
13703
13704    impl<'de> ::core::fmt::Debug for Data<'de> {
13705        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13706            self.as_ref().fmt(f)
13707        }
13708    }
13709
13710    impl<'de> ::fidl_next::IntoNatural for Data<'de> {
13711        type Natural = ::core::option::Option<crate::natural::Data>;
13712    }
13713
13714    impl ::fidl_next::Unconstrained for Data<'static> {}
13715
13716    #[repr(transparent)]
13717    pub struct Capability<'de> {
13718        pub(crate) raw: ::fidl_next::RawWireUnion,
13719        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13720    }
13721
13722    unsafe impl ::fidl_next::Wire for Capability<'static> {
13723        type Decoded<'de> = Capability<'de>;
13724
13725        #[inline]
13726        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13727            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13728            ::fidl_next::RawWireUnion::zero_padding(raw);
13729        }
13730    }
13731
13732    impl<'de> Capability<'de> {
13733        pub fn is_some(&self) -> bool {
13734            self.raw.is_some()
13735        }
13736
13737        pub fn is_none(&self) -> bool {
13738            self.raw.is_none()
13739        }
13740
13741        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Capability<'de>> {
13742            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13743        }
13744
13745        pub fn into_option(self) -> ::core::option::Option<crate::wire::Capability<'de>> {
13746            if self.is_some() {
13747                Some(crate::wire::Capability {
13748                    raw: self.raw,
13749                    _phantom: ::core::marker::PhantomData,
13750                })
13751            } else {
13752                None
13753            }
13754        }
13755    }
13756
13757    unsafe impl<___D> ::fidl_next::Decode<___D> for Capability<'static>
13758    where
13759        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13760        ___D: ::fidl_next::Decoder,
13761        ___D: ::fidl_next::fuchsia::HandleDecoder,
13762    {
13763        fn decode(
13764            mut slot: ::fidl_next::Slot<'_, Self>,
13765            decoder: &mut ___D,
13766            _: (),
13767        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13768            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13769            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13770                1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
13771                    raw,
13772                    decoder,
13773                    (),
13774                )?,
13775
13776                2 => {
13777                    ::fidl_next::RawWireUnion::decode_as::<___D, ::fidl_next::fuchsia::WireHandle>(
13778                        raw,
13779                        decoder,
13780                        (),
13781                    )?
13782                }
13783
13784                3 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
13785                    raw,
13786                    decoder,
13787                    (),
13788                )?,
13789
13790                4 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DictionaryRef>(
13791                    raw,
13792                    decoder,
13793                    (),
13794                )?,
13795
13796                5 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Connector>(
13797                    raw,
13798                    decoder,
13799                    (),
13800                )?,
13801
13802                6 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirConnector>(
13803                    raw,
13804                    decoder,
13805                    (),
13806                )?,
13807
13808                7 => ::fidl_next::RawWireUnion::decode_as::<
13809                    ___D,
13810                    ::fidl_next::ClientEnd<
13811                        ::fidl_next_fuchsia_io::Directory,
13812                        ::fidl_next::fuchsia::WireChannel,
13813                    >,
13814                >(raw, decoder, ())?,
13815
13816                8 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::DirEntry>(
13817                    raw,
13818                    decoder,
13819                    (),
13820                )?,
13821
13822                9 => ::fidl_next::RawWireUnion::decode_as::<
13823                    ___D,
13824                    ::fidl_next::ClientEnd<
13825                        crate::ConnectorRouter,
13826                        ::fidl_next::fuchsia::WireChannel,
13827                    >,
13828                >(raw, decoder, ())?,
13829
13830                10 => ::fidl_next::RawWireUnion::decode_as::<
13831                    ___D,
13832                    ::fidl_next::ClientEnd<
13833                        crate::DictionaryRouter,
13834                        ::fidl_next::fuchsia::WireChannel,
13835                    >,
13836                >(raw, decoder, ())?,
13837
13838                11 => ::fidl_next::RawWireUnion::decode_as::<
13839                    ___D,
13840                    ::fidl_next::ClientEnd<
13841                        crate::DirEntryRouter,
13842                        ::fidl_next::fuchsia::WireChannel,
13843                    >,
13844                >(raw, decoder, ())?,
13845
13846                12 => ::fidl_next::RawWireUnion::decode_as::<
13847                    ___D,
13848                    ::fidl_next::ClientEnd<crate::DataRouter, ::fidl_next::fuchsia::WireChannel>,
13849                >(raw, decoder, ())?,
13850
13851                13 => ::fidl_next::RawWireUnion::decode_as::<
13852                    ___D,
13853                    ::fidl_next::ClientEnd<
13854                        crate::DirConnectorRouter,
13855                        ::fidl_next::fuchsia::WireChannel,
13856                    >,
13857                >(raw, decoder, ())?,
13858
13859                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13860                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
13861            }
13862
13863            Ok(())
13864        }
13865    }
13866
13867    impl<'de> ::core::fmt::Debug for Capability<'de> {
13868        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13869            self.as_ref().fmt(f)
13870        }
13871    }
13872
13873    impl<'de> ::fidl_next::IntoNatural for Capability<'de> {
13874        type Natural = ::core::option::Option<crate::natural::Capability>;
13875    }
13876
13877    impl ::fidl_next::Unconstrained for Capability<'static> {}
13878
13879    #[repr(transparent)]
13880    pub struct ConnectorRouterRouteResponse {
13881        pub(crate) raw: ::fidl_next::RawWireUnion,
13882        pub(crate) _phantom: ::core::marker::PhantomData<()>,
13883    }
13884
13885    unsafe impl ::fidl_next::Wire for ConnectorRouterRouteResponse {
13886        type Decoded<'de> = ConnectorRouterRouteResponse;
13887
13888        #[inline]
13889        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13890            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13891            ::fidl_next::RawWireUnion::zero_padding(raw);
13892        }
13893    }
13894
13895    impl ConnectorRouterRouteResponse {
13896        pub fn is_some(&self) -> bool {
13897            self.raw.is_some()
13898        }
13899
13900        pub fn is_none(&self) -> bool {
13901            self.raw.is_none()
13902        }
13903
13904        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ConnectorRouterRouteResponse> {
13905            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13906        }
13907
13908        pub fn into_option(
13909            self,
13910        ) -> ::core::option::Option<crate::wire::ConnectorRouterRouteResponse> {
13911            if self.is_some() {
13912                Some(crate::wire::ConnectorRouterRouteResponse {
13913                    raw: self.raw,
13914                    _phantom: ::core::marker::PhantomData,
13915                })
13916            } else {
13917                None
13918            }
13919        }
13920    }
13921
13922    unsafe impl<___D> ::fidl_next::Decode<___D> for ConnectorRouterRouteResponse
13923    where
13924        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13925        ___D: ::fidl_next::fuchsia::HandleDecoder,
13926    {
13927        fn decode(
13928            mut slot: ::fidl_next::Slot<'_, Self>,
13929            decoder: &mut ___D,
13930            _: (),
13931        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13932            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
13933            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
13934                1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Connector>(
13935                    raw,
13936                    decoder,
13937                    (),
13938                )?,
13939
13940                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
13941                    raw,
13942                    decoder,
13943                    (),
13944                )?,
13945
13946                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
13947                _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
13948            }
13949
13950            Ok(())
13951        }
13952    }
13953
13954    impl ::core::fmt::Debug for ConnectorRouterRouteResponse {
13955        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13956            self.as_ref().fmt(f)
13957        }
13958    }
13959
13960    impl ::fidl_next::IntoNatural for ConnectorRouterRouteResponse {
13961        type Natural = ::core::option::Option<crate::natural::ConnectorRouterRouteResponse>;
13962    }
13963
13964    impl ::fidl_next::Unconstrained for ConnectorRouterRouteResponse {}
13965
13966    #[repr(transparent)]
13967    pub struct DataRouterRouteResponse<'de> {
13968        pub(crate) raw: ::fidl_next::RawWireUnion,
13969        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
13970    }
13971
13972    unsafe impl ::fidl_next::Wire for DataRouterRouteResponse<'static> {
13973        type Decoded<'de> = DataRouterRouteResponse<'de>;
13974
13975        #[inline]
13976        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13977            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
13978            ::fidl_next::RawWireUnion::zero_padding(raw);
13979        }
13980    }
13981
13982    impl<'de> DataRouterRouteResponse<'de> {
13983        pub fn is_some(&self) -> bool {
13984            self.raw.is_some()
13985        }
13986
13987        pub fn is_none(&self) -> bool {
13988            self.raw.is_none()
13989        }
13990
13991        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DataRouterRouteResponse<'de>> {
13992            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
13993        }
13994
13995        pub fn into_option(
13996            self,
13997        ) -> ::core::option::Option<crate::wire::DataRouterRouteResponse<'de>> {
13998            if self.is_some() {
13999                Some(crate::wire::DataRouterRouteResponse {
14000                    raw: self.raw,
14001                    _phantom: ::core::marker::PhantomData,
14002                })
14003            } else {
14004                None
14005            }
14006        }
14007    }
14008
14009    unsafe impl<___D> ::fidl_next::Decode<___D> for DataRouterRouteResponse<'static>
14010    where
14011        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14012        ___D: ::fidl_next::Decoder,
14013        ___D: ::fidl_next::fuchsia::HandleDecoder,
14014    {
14015        fn decode(
14016            mut slot: ::fidl_next::Slot<'_, Self>,
14017            decoder: &mut ___D,
14018            _: (),
14019        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14020            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14021            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14022                1 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Data<'static>>(
14023                    raw,
14024                    decoder,
14025                    (),
14026                )?,
14027
14028                2 => ::fidl_next::RawWireUnion::decode_as::<___D, crate::wire::Unit>(
14029                    raw,
14030                    decoder,
14031                    (),
14032                )?,
14033
14034                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14035                _ => ::fidl_next::RawWireUnion::decode_unknown(raw, decoder)?,
14036            }
14037
14038            Ok(())
14039        }
14040    }
14041
14042    impl<'de> ::core::fmt::Debug for DataRouterRouteResponse<'de> {
14043        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14044            self.as_ref().fmt(f)
14045        }
14046    }
14047
14048    impl<'de> ::fidl_next::IntoNatural for DataRouterRouteResponse<'de> {
14049        type Natural = ::core::option::Option<crate::natural::DataRouterRouteResponse>;
14050    }
14051
14052    impl ::fidl_next::Unconstrained for DataRouterRouteResponse<'static> {}
14053
14054    #[repr(transparent)]
14055    pub struct DictionaryRouterRouteResponse {
14056        pub(crate) raw: ::fidl_next::RawWireUnion,
14057        pub(crate) _phantom: ::core::marker::PhantomData<()>,
14058    }
14059
14060    unsafe impl ::fidl_next::Wire for DictionaryRouterRouteResponse {
14061        type Decoded<'de> = DictionaryRouterRouteResponse;
14062
14063        #[inline]
14064        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14065            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14066            ::fidl_next::RawWireUnion::zero_padding(raw);
14067        }
14068    }
14069
14070    impl DictionaryRouterRouteResponse {
14071        pub fn is_some(&self) -> bool {
14072            self.raw.is_some()
14073        }
14074
14075        pub fn is_none(&self) -> bool {
14076            self.raw.is_none()
14077        }
14078
14079        pub fn as_ref(
14080            &self,
14081        ) -> ::core::option::Option<&crate::wire::DictionaryRouterRouteResponse> {
14082            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14083        }
14084
14085        pub fn into_option(
14086            self,
14087        ) -> ::core::option::Option<crate::wire::DictionaryRouterRouteResponse> {
14088            if self.is_some() {
14089                Some(crate::wire::DictionaryRouterRouteResponse {
14090                    raw: self.raw,
14091                    _phantom: ::core::marker::PhantomData,
14092                })
14093            } else {
14094                None
14095            }
14096        }
14097    }
14098
14099    unsafe impl<___D> ::fidl_next::Decode<___D> for DictionaryRouterRouteResponse
14100    where
14101        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14102        ___D: ::fidl_next::fuchsia::HandleDecoder,
14103    {
14104        fn decode(
14105            mut slot: ::fidl_next::Slot<'_, Self>,
14106            decoder: &mut ___D,
14107            _: (),
14108        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14109            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14110            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14111                1 => {
14112                    ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DictionaryRef>(
14113                        raw,
14114                        decoder,
14115                        (),
14116                    )?
14117                }
14118
14119                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14120                    raw,
14121                    decoder,
14122                    (),
14123                )?,
14124
14125                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14126                _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14127            }
14128
14129            Ok(())
14130        }
14131    }
14132
14133    impl ::core::fmt::Debug for DictionaryRouterRouteResponse {
14134        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14135            self.as_ref().fmt(f)
14136        }
14137    }
14138
14139    impl ::fidl_next::IntoNatural for DictionaryRouterRouteResponse {
14140        type Natural = ::core::option::Option<crate::natural::DictionaryRouterRouteResponse>;
14141    }
14142
14143    impl ::fidl_next::Unconstrained for DictionaryRouterRouteResponse {}
14144
14145    #[repr(transparent)]
14146    pub struct DirConnectorRouterRouteResponse {
14147        pub(crate) raw: ::fidl_next::RawWireUnion,
14148        pub(crate) _phantom: ::core::marker::PhantomData<()>,
14149    }
14150
14151    unsafe impl ::fidl_next::Wire for DirConnectorRouterRouteResponse {
14152        type Decoded<'de> = DirConnectorRouterRouteResponse;
14153
14154        #[inline]
14155        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14156            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14157            ::fidl_next::RawWireUnion::zero_padding(raw);
14158        }
14159    }
14160
14161    impl DirConnectorRouterRouteResponse {
14162        pub fn is_some(&self) -> bool {
14163            self.raw.is_some()
14164        }
14165
14166        pub fn is_none(&self) -> bool {
14167            self.raw.is_none()
14168        }
14169
14170        pub fn as_ref(
14171            &self,
14172        ) -> ::core::option::Option<&crate::wire::DirConnectorRouterRouteResponse> {
14173            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14174        }
14175
14176        pub fn into_option(
14177            self,
14178        ) -> ::core::option::Option<crate::wire::DirConnectorRouterRouteResponse> {
14179            if self.is_some() {
14180                Some(crate::wire::DirConnectorRouterRouteResponse {
14181                    raw: self.raw,
14182                    _phantom: ::core::marker::PhantomData,
14183                })
14184            } else {
14185                None
14186            }
14187        }
14188    }
14189
14190    unsafe impl<___D> ::fidl_next::Decode<___D> for DirConnectorRouterRouteResponse
14191    where
14192        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14193        ___D: ::fidl_next::fuchsia::HandleDecoder,
14194    {
14195        fn decode(
14196            mut slot: ::fidl_next::Slot<'_, Self>,
14197            decoder: &mut ___D,
14198            _: (),
14199        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14200            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14201            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14202                1 => {
14203                    ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirConnector>(
14204                        raw,
14205                        decoder,
14206                        (),
14207                    )?
14208                }
14209
14210                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14211                    raw,
14212                    decoder,
14213                    (),
14214                )?,
14215
14216                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14217                _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14218            }
14219
14220            Ok(())
14221        }
14222    }
14223
14224    impl ::core::fmt::Debug for DirConnectorRouterRouteResponse {
14225        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14226            self.as_ref().fmt(f)
14227        }
14228    }
14229
14230    impl ::fidl_next::IntoNatural for DirConnectorRouterRouteResponse {
14231        type Natural = ::core::option::Option<crate::natural::DirConnectorRouterRouteResponse>;
14232    }
14233
14234    impl ::fidl_next::Unconstrained for DirConnectorRouterRouteResponse {}
14235
14236    #[repr(transparent)]
14237    pub struct DirEntryRouterRouteResponse {
14238        pub(crate) raw: ::fidl_next::RawWireUnion,
14239        pub(crate) _phantom: ::core::marker::PhantomData<()>,
14240    }
14241
14242    unsafe impl ::fidl_next::Wire for DirEntryRouterRouteResponse {
14243        type Decoded<'de> = DirEntryRouterRouteResponse;
14244
14245        #[inline]
14246        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14247            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14248            ::fidl_next::RawWireUnion::zero_padding(raw);
14249        }
14250    }
14251
14252    impl DirEntryRouterRouteResponse {
14253        pub fn is_some(&self) -> bool {
14254            self.raw.is_some()
14255        }
14256
14257        pub fn is_none(&self) -> bool {
14258            self.raw.is_none()
14259        }
14260
14261        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirEntryRouterRouteResponse> {
14262            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14263        }
14264
14265        pub fn into_option(
14266            self,
14267        ) -> ::core::option::Option<crate::wire::DirEntryRouterRouteResponse> {
14268            if self.is_some() {
14269                Some(crate::wire::DirEntryRouterRouteResponse {
14270                    raw: self.raw,
14271                    _phantom: ::core::marker::PhantomData,
14272                })
14273            } else {
14274                None
14275            }
14276        }
14277    }
14278
14279    unsafe impl<___D> ::fidl_next::Decode<___D> for DirEntryRouterRouteResponse
14280    where
14281        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14282        ___D: ::fidl_next::fuchsia::HandleDecoder,
14283    {
14284        fn decode(
14285            mut slot: ::fidl_next::Slot<'_, Self>,
14286            decoder: &mut ___D,
14287            _: (),
14288        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14289            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14290            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14291                1 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::DirEntry>(
14292                    raw,
14293                    decoder,
14294                    (),
14295                )?,
14296
14297                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14298                    raw,
14299                    decoder,
14300                    (),
14301                )?,
14302
14303                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14304                _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14305            }
14306
14307            Ok(())
14308        }
14309    }
14310
14311    impl ::core::fmt::Debug for DirEntryRouterRouteResponse {
14312        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14313            self.as_ref().fmt(f)
14314        }
14315    }
14316
14317    impl ::fidl_next::IntoNatural for DirEntryRouterRouteResponse {
14318        type Natural = ::core::option::Option<crate::natural::DirEntryRouterRouteResponse>;
14319    }
14320
14321    impl ::fidl_next::Unconstrained for DirEntryRouterRouteResponse {}
14322
14323    #[repr(transparent)]
14324    pub struct DirectoryRouterRouteResponse {
14325        pub(crate) raw: ::fidl_next::RawWireUnion,
14326        pub(crate) _phantom: ::core::marker::PhantomData<()>,
14327    }
14328
14329    unsafe impl ::fidl_next::Wire for DirectoryRouterRouteResponse {
14330        type Decoded<'de> = DirectoryRouterRouteResponse;
14331
14332        #[inline]
14333        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14334            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
14335            ::fidl_next::RawWireUnion::zero_padding(raw);
14336        }
14337    }
14338
14339    impl DirectoryRouterRouteResponse {
14340        pub fn is_some(&self) -> bool {
14341            self.raw.is_some()
14342        }
14343
14344        pub fn is_none(&self) -> bool {
14345            self.raw.is_none()
14346        }
14347
14348        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::DirectoryRouterRouteResponse> {
14349            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
14350        }
14351
14352        pub fn into_option(
14353            self,
14354        ) -> ::core::option::Option<crate::wire::DirectoryRouterRouteResponse> {
14355            if self.is_some() {
14356                Some(crate::wire::DirectoryRouterRouteResponse {
14357                    raw: self.raw,
14358                    _phantom: ::core::marker::PhantomData,
14359                })
14360            } else {
14361                None
14362            }
14363        }
14364    }
14365
14366    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRouterRouteResponse
14367    where
14368        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14369        ___D: ::fidl_next::fuchsia::HandleDecoder,
14370    {
14371        fn decode(
14372            mut slot: ::fidl_next::Slot<'_, Self>,
14373            decoder: &mut ___D,
14374            _: (),
14375        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14376            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
14377            match ::fidl_next::RawWireUnion::encoded_ordinal(raw.as_mut()) {
14378                1 => ::fidl_next::RawWireUnion::decode_as_static::<
14379                    ___D,
14380                    ::fidl_next::ClientEnd<
14381                        ::fidl_next_fuchsia_io::Directory,
14382                        ::fidl_next::fuchsia::WireChannel,
14383                    >,
14384                >(raw, decoder, ())?,
14385
14386                2 => ::fidl_next::RawWireUnion::decode_as_static::<___D, crate::wire::Unit>(
14387                    raw,
14388                    decoder,
14389                    (),
14390                )?,
14391
14392                0 => ::fidl_next::RawWireUnion::decode_absent(raw)?,
14393                _ => ::fidl_next::RawWireUnion::decode_unknown_static(raw, decoder)?,
14394            }
14395
14396            Ok(())
14397        }
14398    }
14399
14400    impl ::core::fmt::Debug for DirectoryRouterRouteResponse {
14401        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
14402            self.as_ref().fmt(f)
14403        }
14404    }
14405
14406    impl ::fidl_next::IntoNatural for DirectoryRouterRouteResponse {
14407        type Natural = ::core::option::Option<crate::natural::DirectoryRouterRouteResponse>;
14408    }
14409
14410    impl ::fidl_next::Unconstrained for DirectoryRouterRouteResponse {}
14411}
14412
14413pub mod generic {
14414
14415    pub struct Unit {}
14416
14417    impl ::fidl_next::Encodable for Unit {
14418        type Encoded = crate::wire::Unit;
14419    }
14420
14421    unsafe impl<___E> ::fidl_next::Encode<___E> for Unit
14422    where
14423        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14424    {
14425        #[inline]
14426        fn encode(
14427            self,
14428            encoder_: &mut ___E,
14429            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14430            _: (),
14431        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14432            ::fidl_next::munge! {
14433                let Self::Encoded {
14434
14435                        _empty,
14436
14437
14438                } = out_;
14439            }
14440
14441            Ok(())
14442        }
14443    }
14444
14445    pub struct DictionaryRef<T0> {
14446        pub token: T0,
14447    }
14448
14449    impl<T0> ::fidl_next::Encodable for DictionaryRef<T0>
14450    where
14451        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14452    {
14453        type Encoded = crate::wire::DictionaryRef;
14454    }
14455
14456    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryRef<T0>
14457    where
14458        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14459        ___E: ::fidl_next::fuchsia::HandleEncoder,
14460        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14461    {
14462        #[inline]
14463        fn encode(
14464            self,
14465            encoder_: &mut ___E,
14466            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14467            _: (),
14468        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14469            ::fidl_next::munge! {
14470                let Self::Encoded {
14471
14472                    token,
14473
14474                } = out_;
14475            }
14476
14477            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14478
14479            Ok(())
14480        }
14481    }
14482
14483    pub struct Connector<T0> {
14484        pub token: T0,
14485    }
14486
14487    impl<T0> ::fidl_next::Encodable for Connector<T0>
14488    where
14489        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14490    {
14491        type Encoded = crate::wire::Connector;
14492    }
14493
14494    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Connector<T0>
14495    where
14496        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14497        ___E: ::fidl_next::fuchsia::HandleEncoder,
14498        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14499    {
14500        #[inline]
14501        fn encode(
14502            self,
14503            encoder_: &mut ___E,
14504            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14505            _: (),
14506        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14507            ::fidl_next::munge! {
14508                let Self::Encoded {
14509
14510                    token,
14511
14512                } = out_;
14513            }
14514
14515            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14516
14517            Ok(())
14518        }
14519    }
14520
14521    pub struct DirConnector<T0> {
14522        pub token: T0,
14523    }
14524
14525    impl<T0> ::fidl_next::Encodable for DirConnector<T0>
14526    where
14527        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14528    {
14529        type Encoded = crate::wire::DirConnector;
14530    }
14531
14532    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirConnector<T0>
14533    where
14534        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14535        ___E: ::fidl_next::fuchsia::HandleEncoder,
14536        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14537    {
14538        #[inline]
14539        fn encode(
14540            self,
14541            encoder_: &mut ___E,
14542            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14543            _: (),
14544        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14545            ::fidl_next::munge! {
14546                let Self::Encoded {
14547
14548                    token,
14549
14550                } = out_;
14551            }
14552
14553            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14554
14555            Ok(())
14556        }
14557    }
14558
14559    pub struct DirEntry<T0> {
14560        pub token: T0,
14561    }
14562
14563    impl<T0> ::fidl_next::Encodable for DirEntry<T0>
14564    where
14565        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
14566    {
14567        type Encoded = crate::wire::DirEntry;
14568    }
14569
14570    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirEntry<T0>
14571    where
14572        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14573        ___E: ::fidl_next::fuchsia::HandleEncoder,
14574        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
14575    {
14576        #[inline]
14577        fn encode(
14578            self,
14579            encoder_: &mut ___E,
14580            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14581            _: (),
14582        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14583            ::fidl_next::munge! {
14584                let Self::Encoded {
14585
14586                    token,
14587
14588                } = out_;
14589            }
14590
14591            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
14592
14593            Ok(())
14594        }
14595    }
14596
14597    pub struct CapabilityStoreDuplicateRequest<T0, T1> {
14598        pub id: T0,
14599
14600        pub dest_id: T1,
14601    }
14602
14603    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDuplicateRequest<T0, T1>
14604    where
14605        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14606        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14607    {
14608        type Encoded = crate::wire::CapabilityStoreDuplicateRequest;
14609    }
14610
14611    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDuplicateRequest<T0, T1>
14612    where
14613        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14614        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14615        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14616    {
14617        #[inline]
14618        fn encode(
14619            self,
14620            encoder_: &mut ___E,
14621            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14622            _: (),
14623        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14624            ::fidl_next::munge! {
14625                let Self::Encoded {
14626
14627                    id,
14628                    dest_id,
14629
14630                } = out_;
14631            }
14632
14633            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14634
14635            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
14636
14637            Ok(())
14638        }
14639    }
14640
14641    pub struct CapabilityStoreDropRequest<T0> {
14642        pub id: T0,
14643    }
14644
14645    impl<T0> ::fidl_next::Encodable for CapabilityStoreDropRequest<T0>
14646    where
14647        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14648    {
14649        type Encoded = crate::wire::CapabilityStoreDropRequest;
14650    }
14651
14652    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreDropRequest<T0>
14653    where
14654        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14655        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14656    {
14657        #[inline]
14658        fn encode(
14659            self,
14660            encoder_: &mut ___E,
14661            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14662            _: (),
14663        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14664            ::fidl_next::munge! {
14665                let Self::Encoded {
14666
14667                    id,
14668
14669                } = out_;
14670            }
14671
14672            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14673
14674            Ok(())
14675        }
14676    }
14677
14678    pub struct CapabilityStoreExportRequest<T0> {
14679        pub id: T0,
14680    }
14681
14682    impl<T0> ::fidl_next::Encodable for CapabilityStoreExportRequest<T0>
14683    where
14684        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14685    {
14686        type Encoded = crate::wire::CapabilityStoreExportRequest;
14687    }
14688
14689    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreExportRequest<T0>
14690    where
14691        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14692        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14693    {
14694        #[inline]
14695        fn encode(
14696            self,
14697            encoder_: &mut ___E,
14698            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14699            _: (),
14700        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14701            ::fidl_next::munge! {
14702                let Self::Encoded {
14703
14704                    id,
14705
14706                } = out_;
14707            }
14708
14709            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14710
14711            Ok(())
14712        }
14713    }
14714
14715    pub struct CapabilityStoreConnectorCreateRequest<T0, T1> {
14716        pub id: T0,
14717
14718        pub receiver: T1,
14719    }
14720
14721    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreConnectorCreateRequest<T0, T1>
14722    where
14723        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14724        T1: ::fidl_next::Encodable<
14725                Encoded = ::fidl_next::ClientEnd<
14726                    crate::Receiver,
14727                    ::fidl_next::fuchsia::WireChannel,
14728                >,
14729            >,
14730    {
14731        type Encoded = crate::wire::CapabilityStoreConnectorCreateRequest;
14732    }
14733
14734    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14735        for CapabilityStoreConnectorCreateRequest<T0, T1>
14736    where
14737        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14738        ___E: ::fidl_next::fuchsia::HandleEncoder,
14739        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14740        T1: ::fidl_next::Encode<
14741                ___E,
14742                Encoded = ::fidl_next::ClientEnd<
14743                    crate::Receiver,
14744                    ::fidl_next::fuchsia::WireChannel,
14745                >,
14746            >,
14747    {
14748        #[inline]
14749        fn encode(
14750            self,
14751            encoder_: &mut ___E,
14752            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14753            _: (),
14754        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14755            ::fidl_next::munge! {
14756                let Self::Encoded {
14757
14758                    id,
14759                    receiver,
14760
14761                } = out_;
14762            }
14763
14764            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14765
14766            ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
14767
14768            Ok(())
14769        }
14770    }
14771
14772    pub struct CapabilityStoreConnectorOpenRequest<T0, T1> {
14773        pub id: T0,
14774
14775        pub server_end: T1,
14776    }
14777
14778    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreConnectorOpenRequest<T0, T1>
14779    where
14780        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14781        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14782    {
14783        type Encoded = crate::wire::CapabilityStoreConnectorOpenRequest;
14784    }
14785
14786    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreConnectorOpenRequest<T0, T1>
14787    where
14788        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14789        ___E: ::fidl_next::fuchsia::HandleEncoder,
14790        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14791        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14792    {
14793        #[inline]
14794        fn encode(
14795            self,
14796            encoder_: &mut ___E,
14797            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14798            _: (),
14799        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14800            ::fidl_next::munge! {
14801                let Self::Encoded {
14802
14803                    id,
14804                    server_end,
14805
14806                } = out_;
14807            }
14808
14809            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14810
14811            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
14812
14813            Ok(())
14814        }
14815    }
14816
14817    pub struct CapabilityStoreDictionaryCreateRequest<T0> {
14818        pub id: T0,
14819    }
14820
14821    impl<T0> ::fidl_next::Encodable for CapabilityStoreDictionaryCreateRequest<T0>
14822    where
14823        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14824    {
14825        type Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest;
14826    }
14827
14828    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCreateRequest<T0>
14829    where
14830        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14831        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14832    {
14833        #[inline]
14834        fn encode(
14835            self,
14836            encoder_: &mut ___E,
14837            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14838            _: (),
14839        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14840            ::fidl_next::munge! {
14841                let Self::Encoded {
14842
14843                    id,
14844
14845                } = out_;
14846            }
14847
14848            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14849
14850            Ok(())
14851        }
14852    }
14853
14854    pub struct CapabilityStoreDictionaryLegacyImportRequest<T0, T1> {
14855        pub id: T0,
14856
14857        pub client_end: T1,
14858    }
14859
14860    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
14861    where
14862        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14863        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14864    {
14865        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
14866    }
14867
14868    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14869        for CapabilityStoreDictionaryLegacyImportRequest<T0, T1>
14870    where
14871        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14872        ___E: ::fidl_next::fuchsia::HandleEncoder,
14873        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14874        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14875    {
14876        #[inline]
14877        fn encode(
14878            self,
14879            encoder_: &mut ___E,
14880            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14881            _: (),
14882        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14883            ::fidl_next::munge! {
14884                let Self::Encoded {
14885
14886                    id,
14887                    client_end,
14888
14889                } = out_;
14890            }
14891
14892            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14893
14894            ::fidl_next::Encode::encode(self.client_end, encoder_, client_end, ())?;
14895
14896            Ok(())
14897        }
14898    }
14899
14900    pub struct CapabilityStoreDictionaryLegacyExportRequest<T0, T1> {
14901        pub id: T0,
14902
14903        pub server_end: T1,
14904    }
14905
14906    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
14907    where
14908        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14909        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
14910    {
14911        type Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
14912    }
14913
14914    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
14915        for CapabilityStoreDictionaryLegacyExportRequest<T0, T1>
14916    where
14917        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14918        ___E: ::fidl_next::fuchsia::HandleEncoder,
14919        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14920        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
14921    {
14922        #[inline]
14923        fn encode(
14924            self,
14925            encoder_: &mut ___E,
14926            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14927            _: (),
14928        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14929            ::fidl_next::munge! {
14930                let Self::Encoded {
14931
14932                    id,
14933                    server_end,
14934
14935                } = out_;
14936            }
14937
14938            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
14939
14940            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
14941
14942            Ok(())
14943        }
14944    }
14945
14946    pub struct DictionaryItem<T0, T1> {
14947        pub key: T0,
14948
14949        pub value: T1,
14950    }
14951
14952    impl<T0, T1> ::fidl_next::Encodable for DictionaryItem<T0, T1>
14953    where
14954        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
14955        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
14956    {
14957        type Encoded = crate::wire::DictionaryItem<'static>;
14958    }
14959
14960    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryItem<T0, T1>
14961    where
14962        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
14963        ___E: ::fidl_next::Encoder,
14964        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
14965        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
14966    {
14967        #[inline]
14968        fn encode(
14969            self,
14970            encoder_: &mut ___E,
14971            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
14972            _: (),
14973        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
14974            ::fidl_next::munge! {
14975                let Self::Encoded {
14976
14977                    key,
14978                    value,
14979
14980                } = out_;
14981            }
14982
14983            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
14984
14985            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
14986
14987            Ok(())
14988        }
14989    }
14990
14991    pub struct CapabilityStoreDictionaryInsertRequest<T0, T1> {
14992        pub id: T0,
14993
14994        pub item: T1,
14995    }
14996
14997    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryInsertRequest<T0, T1>
14998    where
14999        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15000        T1: ::fidl_next::Encodable<Encoded = crate::wire::DictionaryItem<'static>>,
15001    {
15002        type Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
15003    }
15004
15005    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15006        for CapabilityStoreDictionaryInsertRequest<T0, T1>
15007    where
15008        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15009        ___E: ::fidl_next::Encoder,
15010        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15011        T1: ::fidl_next::Encode<___E, Encoded = crate::wire::DictionaryItem<'static>>,
15012    {
15013        #[inline]
15014        fn encode(
15015            self,
15016            encoder_: &mut ___E,
15017            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15018            _: (),
15019        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15020            ::fidl_next::munge! {
15021                let Self::Encoded {
15022
15023                    id,
15024                    item,
15025
15026                } = out_;
15027            }
15028
15029            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15030
15031            ::fidl_next::Encode::encode(self.item, encoder_, item, ())?;
15032
15033            Ok(())
15034        }
15035    }
15036
15037    pub struct CapabilityStoreDictionaryGetRequest<T0, T1, T2> {
15038        pub id: T0,
15039
15040        pub key: T1,
15041
15042        pub dest_id: T2,
15043    }
15044
15045    impl<T0, T1, T2> ::fidl_next::Encodable for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
15046    where
15047        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15048        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15049        T2: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15050    {
15051        type Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
15052    }
15053
15054    unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E>
15055        for CapabilityStoreDictionaryGetRequest<T0, T1, T2>
15056    where
15057        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15058        ___E: ::fidl_next::Encoder,
15059        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15060        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15061        T2: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15062    {
15063        #[inline]
15064        fn encode(
15065            self,
15066            encoder_: &mut ___E,
15067            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15068            _: (),
15069        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15070            ::fidl_next::munge! {
15071                let Self::Encoded {
15072
15073                    id,
15074                    key,
15075                    dest_id,
15076
15077                } = out_;
15078            }
15079
15080            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15081
15082            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15083
15084            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15085
15086            Ok(())
15087        }
15088    }
15089
15090    pub struct WrappedCapabilityId<T0> {
15091        pub id: T0,
15092    }
15093
15094    impl<T0> ::fidl_next::Encodable for WrappedCapabilityId<T0>
15095    where
15096        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15097    {
15098        type Encoded = crate::wire::WrappedCapabilityId;
15099    }
15100
15101    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for WrappedCapabilityId<T0>
15102    where
15103        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15104        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15105    {
15106        #[inline]
15107        fn encode(
15108            self,
15109            encoder_: &mut ___E,
15110            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15111            _: (),
15112        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15113            ::fidl_next::munge! {
15114                let Self::Encoded {
15115
15116                    id,
15117
15118                } = out_;
15119            }
15120
15121            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15122
15123            Ok(())
15124        }
15125    }
15126
15127    pub struct CapabilityStoreDictionaryRemoveRequest<T0, T1, T2> {
15128        pub id: T0,
15129
15130        pub key: T1,
15131
15132        pub dest_id: T2,
15133    }
15134
15135    impl<T0, T1, T2> ::fidl_next::Encodable for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
15136    where
15137        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15138        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15139        T2: ::fidl_next::Encodable<
15140                Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15141            >,
15142    {
15143        type Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
15144    }
15145
15146    unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<___E>
15147        for CapabilityStoreDictionaryRemoveRequest<T0, T1, T2>
15148    where
15149        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15150        ___E: ::fidl_next::Encoder,
15151        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15152        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15153        T2: ::fidl_next::Encode<
15154                ___E,
15155                Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15156            >,
15157    {
15158        #[inline]
15159        fn encode(
15160            self,
15161            encoder_: &mut ___E,
15162            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15163            _: (),
15164        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15165            ::fidl_next::munge! {
15166                let Self::Encoded {
15167
15168                    id,
15169                    key,
15170                    dest_id,
15171
15172                } = out_;
15173            }
15174
15175            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15176
15177            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15178
15179            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15180
15181            Ok(())
15182        }
15183    }
15184
15185    pub struct CapabilityStoreDictionaryCopyRequest<T0, T1> {
15186        pub id: T0,
15187
15188        pub dest_id: T1,
15189    }
15190
15191    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryCopyRequest<T0, T1>
15192    where
15193        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15194        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15195    {
15196        type Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest;
15197    }
15198
15199    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryCopyRequest<T0, T1>
15200    where
15201        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15202        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15203        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15204    {
15205        #[inline]
15206        fn encode(
15207            self,
15208            encoder_: &mut ___E,
15209            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15210            _: (),
15211        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15212            ::fidl_next::munge! {
15213                let Self::Encoded {
15214
15215                    id,
15216                    dest_id,
15217
15218                } = out_;
15219            }
15220
15221            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15222
15223            ::fidl_next::Encode::encode(self.dest_id, encoder_, dest_id, ())?;
15224
15225            Ok(())
15226        }
15227    }
15228
15229    pub struct CapabilityStoreDictionaryKeysRequest<T0, T1> {
15230        pub id: T0,
15231
15232        pub iterator: T1,
15233    }
15234
15235    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryKeysRequest<T0, T1>
15236    where
15237        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15238        T1: ::fidl_next::Encodable<
15239                Encoded = ::fidl_next::ServerEnd<
15240                    crate::DictionaryKeysIterator,
15241                    ::fidl_next::fuchsia::WireChannel,
15242                >,
15243            >,
15244    {
15245        type Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest;
15246    }
15247
15248    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreDictionaryKeysRequest<T0, T1>
15249    where
15250        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15251        ___E: ::fidl_next::fuchsia::HandleEncoder,
15252        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15253        T1: ::fidl_next::Encode<
15254                ___E,
15255                Encoded = ::fidl_next::ServerEnd<
15256                    crate::DictionaryKeysIterator,
15257                    ::fidl_next::fuchsia::WireChannel,
15258                >,
15259            >,
15260    {
15261        #[inline]
15262        fn encode(
15263            self,
15264            encoder_: &mut ___E,
15265            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15266            _: (),
15267        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15268            ::fidl_next::munge! {
15269                let Self::Encoded {
15270
15271                    id,
15272                    iterator,
15273
15274                } = out_;
15275            }
15276
15277            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15278
15279            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15280
15281            Ok(())
15282        }
15283    }
15284
15285    pub struct CapabilityStoreDictionaryEnumerateRequest<T0, T1> {
15286        pub id: T0,
15287
15288        pub iterator: T1,
15289    }
15290
15291    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
15292    where
15293        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15294        T1: ::fidl_next::Encodable<
15295                Encoded = ::fidl_next::ServerEnd<
15296                    crate::DictionaryEnumerateIterator,
15297                    ::fidl_next::fuchsia::WireChannel,
15298                >,
15299            >,
15300    {
15301        type Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
15302    }
15303
15304    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15305        for CapabilityStoreDictionaryEnumerateRequest<T0, T1>
15306    where
15307        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15308        ___E: ::fidl_next::fuchsia::HandleEncoder,
15309        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15310        T1: ::fidl_next::Encode<
15311                ___E,
15312                Encoded = ::fidl_next::ServerEnd<
15313                    crate::DictionaryEnumerateIterator,
15314                    ::fidl_next::fuchsia::WireChannel,
15315                >,
15316            >,
15317    {
15318        #[inline]
15319        fn encode(
15320            self,
15321            encoder_: &mut ___E,
15322            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15323            _: (),
15324        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15325            ::fidl_next::munge! {
15326                let Self::Encoded {
15327
15328                    id,
15329                    iterator,
15330
15331                } = out_;
15332            }
15333
15334            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15335
15336            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15337
15338            Ok(())
15339        }
15340    }
15341
15342    pub struct CapabilityStoreDictionaryDrainRequest<T0, T1> {
15343        pub id: T0,
15344
15345        pub iterator: T1,
15346    }
15347
15348    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDictionaryDrainRequest<T0, T1>
15349    where
15350        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15351        T1: ::fidl_next::Encodable<
15352                Encoded = ::fidl_next::ServerEnd<
15353                    crate::DictionaryDrainIterator,
15354                    ::fidl_next::fuchsia::WireOptionalChannel,
15355                >,
15356            >,
15357    {
15358        type Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest;
15359    }
15360
15361    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15362        for CapabilityStoreDictionaryDrainRequest<T0, T1>
15363    where
15364        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15365        ___E: ::fidl_next::fuchsia::HandleEncoder,
15366        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15367        T1: ::fidl_next::Encode<
15368                ___E,
15369                Encoded = ::fidl_next::ServerEnd<
15370                    crate::DictionaryDrainIterator,
15371                    ::fidl_next::fuchsia::WireOptionalChannel,
15372                >,
15373            >,
15374    {
15375        #[inline]
15376        fn encode(
15377            self,
15378            encoder_: &mut ___E,
15379            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15380            _: (),
15381        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15382            ::fidl_next::munge! {
15383                let Self::Encoded {
15384
15385                    id,
15386                    iterator,
15387
15388                } = out_;
15389            }
15390
15391            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15392
15393            ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
15394
15395            Ok(())
15396        }
15397    }
15398
15399    pub struct CapabilityStoreExportResponse<T0> {
15400        pub capability: T0,
15401    }
15402
15403    impl<T0> ::fidl_next::Encodable for CapabilityStoreExportResponse<T0>
15404    where
15405        T0: ::fidl_next::Encodable<Encoded = crate::wire::Capability<'static>>,
15406    {
15407        type Encoded = crate::wire::CapabilityStoreExportResponse<'static>;
15408    }
15409
15410    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for CapabilityStoreExportResponse<T0>
15411    where
15412        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15413        ___E: ::fidl_next::Encoder,
15414        ___E: ::fidl_next::fuchsia::HandleEncoder,
15415        T0: ::fidl_next::Encode<___E, Encoded = crate::wire::Capability<'static>>,
15416    {
15417        #[inline]
15418        fn encode(
15419            self,
15420            encoder_: &mut ___E,
15421            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15422            _: (),
15423        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15424            ::fidl_next::munge! {
15425                let Self::Encoded {
15426
15427                    capability,
15428
15429                } = out_;
15430            }
15431
15432            ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
15433
15434            Ok(())
15435        }
15436    }
15437
15438    pub struct CapabilityStoreImportRequest<T0, T1> {
15439        pub id: T0,
15440
15441        pub capability: T1,
15442    }
15443
15444    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreImportRequest<T0, T1>
15445    where
15446        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15447        T1: ::fidl_next::Encodable<Encoded = crate::wire::Capability<'static>>,
15448    {
15449        type Encoded = crate::wire::CapabilityStoreImportRequest<'static>;
15450    }
15451
15452    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for CapabilityStoreImportRequest<T0, T1>
15453    where
15454        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15455        ___E: ::fidl_next::Encoder,
15456        ___E: ::fidl_next::fuchsia::HandleEncoder,
15457        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15458        T1: ::fidl_next::Encode<___E, Encoded = crate::wire::Capability<'static>>,
15459    {
15460        #[inline]
15461        fn encode(
15462            self,
15463            encoder_: &mut ___E,
15464            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15465            _: (),
15466        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15467            ::fidl_next::munge! {
15468                let Self::Encoded {
15469
15470                    id,
15471                    capability,
15472
15473                } = out_;
15474            }
15475
15476            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15477
15478            ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
15479
15480            Ok(())
15481        }
15482    }
15483
15484    pub struct CapabilityStoreDirConnectorCreateRequest<T0, T1> {
15485        pub id: T0,
15486
15487        pub receiver: T1,
15488    }
15489
15490    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDirConnectorCreateRequest<T0, T1>
15491    where
15492        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15493        T1: ::fidl_next::Encodable<
15494                Encoded = ::fidl_next::ClientEnd<
15495                    crate::DirReceiver,
15496                    ::fidl_next::fuchsia::WireChannel,
15497                >,
15498            >,
15499    {
15500        type Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest;
15501    }
15502
15503    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15504        for CapabilityStoreDirConnectorCreateRequest<T0, T1>
15505    where
15506        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15507        ___E: ::fidl_next::fuchsia::HandleEncoder,
15508        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15509        T1: ::fidl_next::Encode<
15510                ___E,
15511                Encoded = ::fidl_next::ClientEnd<
15512                    crate::DirReceiver,
15513                    ::fidl_next::fuchsia::WireChannel,
15514                >,
15515            >,
15516    {
15517        #[inline]
15518        fn encode(
15519            self,
15520            encoder_: &mut ___E,
15521            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15522            _: (),
15523        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15524            ::fidl_next::munge! {
15525                let Self::Encoded {
15526
15527                    id,
15528                    receiver,
15529
15530                } = out_;
15531            }
15532
15533            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15534
15535            ::fidl_next::Encode::encode(self.receiver, encoder_, receiver, ())?;
15536
15537            Ok(())
15538        }
15539    }
15540
15541    pub struct CapabilityStoreDirConnectorOpenRequest<T0, T1> {
15542        pub id: T0,
15543
15544        pub server_end: T1,
15545    }
15546
15547    impl<T0, T1> ::fidl_next::Encodable for CapabilityStoreDirConnectorOpenRequest<T0, T1>
15548    where
15549        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15550        T1: ::fidl_next::Encodable<
15551                Encoded = ::fidl_next::ServerEnd<
15552                    ::fidl_next_fuchsia_io::Directory,
15553                    ::fidl_next::fuchsia::WireChannel,
15554                >,
15555            >,
15556    {
15557        type Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest;
15558    }
15559
15560    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15561        for CapabilityStoreDirConnectorOpenRequest<T0, T1>
15562    where
15563        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15564        ___E: ::fidl_next::fuchsia::HandleEncoder,
15565        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15566        T1: ::fidl_next::Encode<
15567                ___E,
15568                Encoded = ::fidl_next::ServerEnd<
15569                    ::fidl_next_fuchsia_io::Directory,
15570                    ::fidl_next::fuchsia::WireChannel,
15571                >,
15572            >,
15573    {
15574        #[inline]
15575        fn encode(
15576            self,
15577            encoder_: &mut ___E,
15578            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15579            _: (),
15580        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15581            ::fidl_next::munge! {
15582                let Self::Encoded {
15583
15584                    id,
15585                    server_end,
15586
15587                } = out_;
15588            }
15589
15590            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
15591
15592            ::fidl_next::Encode::encode(self.server_end, encoder_, server_end, ())?;
15593
15594            Ok(())
15595        }
15596    }
15597
15598    pub struct InstanceToken<T0> {
15599        pub token: T0,
15600    }
15601
15602    impl<T0> ::fidl_next::Encodable for InstanceToken<T0>
15603    where
15604        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireEventPair>,
15605    {
15606        type Encoded = crate::wire::InstanceToken;
15607    }
15608
15609    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for InstanceToken<T0>
15610    where
15611        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15612        ___E: ::fidl_next::fuchsia::HandleEncoder,
15613        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireEventPair>,
15614    {
15615        #[inline]
15616        fn encode(
15617            self,
15618            encoder_: &mut ___E,
15619            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15620            _: (),
15621        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15622            ::fidl_next::munge! {
15623                let Self::Encoded {
15624
15625                    token,
15626
15627                } = out_;
15628            }
15629
15630            ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
15631
15632            Ok(())
15633        }
15634    }
15635
15636    pub struct DictionaryDrainIteratorGetNextRequest<T0, T1> {
15637        pub start_id: T0,
15638
15639        pub limit: T1,
15640    }
15641
15642    impl<T0, T1> ::fidl_next::Encodable for DictionaryDrainIteratorGetNextRequest<T0, T1>
15643    where
15644        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15645        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
15646    {
15647        type Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest;
15648    }
15649
15650    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15651        for DictionaryDrainIteratorGetNextRequest<T0, T1>
15652    where
15653        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15654        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15655        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
15656    {
15657        #[inline]
15658        fn encode(
15659            self,
15660            encoder_: &mut ___E,
15661            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15662            _: (),
15663        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15664            ::fidl_next::munge! {
15665                let Self::Encoded {
15666
15667                    start_id,
15668                    limit,
15669
15670                } = out_;
15671            }
15672
15673            ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
15674
15675            ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
15676
15677            Ok(())
15678        }
15679    }
15680
15681    pub struct DictionaryDrainIteratorGetNextResponse<T0, T1> {
15682        pub items: T0,
15683
15684        pub end_id: T1,
15685    }
15686
15687    impl<T0, T1> ::fidl_next::Encodable for DictionaryDrainIteratorGetNextResponse<T0, T1>
15688    where
15689        T0: ::fidl_next::Encodable<
15690                Encoded = ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
15691            >,
15692        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15693    {
15694        type Encoded = crate::wire::DictionaryDrainIteratorGetNextResponse<'static>;
15695    }
15696
15697    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15698        for DictionaryDrainIteratorGetNextResponse<T0, T1>
15699    where
15700        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15701        ___E: ::fidl_next::Encoder,
15702        ___E: ::fidl_next::fuchsia::HandleEncoder,
15703        T0: ::fidl_next::Encode<
15704                ___E,
15705                Encoded = ::fidl_next::WireVector<'static, crate::wire::DictionaryItem<'static>>,
15706            >,
15707        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15708    {
15709        #[inline]
15710        fn encode(
15711            self,
15712            encoder_: &mut ___E,
15713            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15714            _: (),
15715        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15716            ::fidl_next::munge! {
15717                let Self::Encoded {
15718
15719                    items,
15720                    end_id,
15721
15722                } = out_;
15723            }
15724
15725            ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
15726
15727            ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
15728
15729            Ok(())
15730        }
15731    }
15732
15733    pub struct DictionaryEnumerateIteratorGetNextRequest<T0, T1> {
15734        pub start_id: T0,
15735
15736        pub limit: T1,
15737    }
15738
15739    impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
15740    where
15741        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15742        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU32>,
15743    {
15744        type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
15745    }
15746
15747    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15748        for DictionaryEnumerateIteratorGetNextRequest<T0, T1>
15749    where
15750        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15751        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15752        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU32>,
15753    {
15754        #[inline]
15755        fn encode(
15756            self,
15757            encoder_: &mut ___E,
15758            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15759            _: (),
15760        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15761            ::fidl_next::munge! {
15762                let Self::Encoded {
15763
15764                    start_id,
15765                    limit,
15766
15767                } = out_;
15768            }
15769
15770            ::fidl_next::Encode::encode(self.start_id, encoder_, start_id, ())?;
15771
15772            ::fidl_next::Encode::encode(self.limit, encoder_, limit, ())?;
15773
15774            Ok(())
15775        }
15776    }
15777
15778    pub struct DictionaryOptionalItem<T0, T1> {
15779        pub key: T0,
15780
15781        pub value: T1,
15782    }
15783
15784    impl<T0, T1> ::fidl_next::Encodable for DictionaryOptionalItem<T0, T1>
15785    where
15786        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
15787        T1: ::fidl_next::Encodable<
15788                Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15789            >,
15790    {
15791        type Encoded = crate::wire::DictionaryOptionalItem<'static>;
15792    }
15793
15794    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for DictionaryOptionalItem<T0, T1>
15795    where
15796        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15797        ___E: ::fidl_next::Encoder,
15798        ___E: ::fidl_next::fuchsia::HandleEncoder,
15799        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
15800        T1: ::fidl_next::Encode<
15801                ___E,
15802                Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
15803            >,
15804    {
15805        #[inline]
15806        fn encode(
15807            self,
15808            encoder_: &mut ___E,
15809            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15810            _: (),
15811        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15812            ::fidl_next::munge! {
15813                let Self::Encoded {
15814
15815                    key,
15816                    value,
15817
15818                } = out_;
15819            }
15820
15821            ::fidl_next::Encode::encode(self.key, encoder_, key, 255)?;
15822
15823            ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
15824
15825            Ok(())
15826        }
15827    }
15828
15829    pub struct DictionaryEnumerateIteratorGetNextResponse<T0, T1> {
15830        pub items: T0,
15831
15832        pub end_id: T1,
15833    }
15834
15835    impl<T0, T1> ::fidl_next::Encodable for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
15836    where
15837        T0: ::fidl_next::Encodable<
15838                Encoded = ::fidl_next::WireVector<
15839                    'static,
15840                    crate::wire::DictionaryOptionalItem<'static>,
15841                >,
15842            >,
15843        T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireU64>,
15844    {
15845        type Encoded = crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>;
15846    }
15847
15848    unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E>
15849        for DictionaryEnumerateIteratorGetNextResponse<T0, T1>
15850    where
15851        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15852        ___E: ::fidl_next::Encoder,
15853        ___E: ::fidl_next::fuchsia::HandleEncoder,
15854        T0: ::fidl_next::Encode<
15855                ___E,
15856                Encoded = ::fidl_next::WireVector<
15857                    'static,
15858                    crate::wire::DictionaryOptionalItem<'static>,
15859                >,
15860            >,
15861        T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireU64>,
15862    {
15863        #[inline]
15864        fn encode(
15865            self,
15866            encoder_: &mut ___E,
15867            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15868            _: (),
15869        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15870            ::fidl_next::munge! {
15871                let Self::Encoded {
15872
15873                    items,
15874                    end_id,
15875
15876                } = out_;
15877            }
15878
15879            ::fidl_next::Encode::encode(self.items, encoder_, items, (128, ()))?;
15880
15881            ::fidl_next::Encode::encode(self.end_id, encoder_, end_id, ())?;
15882
15883            Ok(())
15884        }
15885    }
15886
15887    pub struct DictionaryKeysIteratorGetNextResponse<T0> {
15888        pub keys: T0,
15889    }
15890
15891    impl<T0> ::fidl_next::Encodable for DictionaryKeysIteratorGetNextResponse<T0>
15892    where
15893        T0: ::fidl_next::Encodable<
15894                Encoded = ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
15895            >,
15896    {
15897        type Encoded = crate::wire::DictionaryKeysIteratorGetNextResponse<'static>;
15898    }
15899
15900    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DictionaryKeysIteratorGetNextResponse<T0>
15901    where
15902        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15903        ___E: ::fidl_next::Encoder,
15904        ___E: ::fidl_next::fuchsia::HandleEncoder,
15905        T0: ::fidl_next::Encode<
15906                ___E,
15907                Encoded = ::fidl_next::WireVector<'static, ::fidl_next::WireString<'static>>,
15908            >,
15909    {
15910        #[inline]
15911        fn encode(
15912            self,
15913            encoder_: &mut ___E,
15914            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15915            _: (),
15916        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15917            ::fidl_next::munge! {
15918                let Self::Encoded {
15919
15920                    keys,
15921
15922                } = out_;
15923            }
15924
15925            ::fidl_next::Encode::encode(self.keys, encoder_, keys, (128, 255))?;
15926
15927            Ok(())
15928        }
15929    }
15930
15931    pub struct DirReceiverReceiveRequest<T0> {
15932        pub channel: T0,
15933    }
15934
15935    impl<T0> ::fidl_next::Encodable for DirReceiverReceiveRequest<T0>
15936    where
15937        T0: ::fidl_next::Encodable<
15938                Encoded = ::fidl_next::ServerEnd<
15939                    ::fidl_next_fuchsia_io::Directory,
15940                    ::fidl_next::fuchsia::WireChannel,
15941                >,
15942            >,
15943    {
15944        type Encoded = crate::wire::DirReceiverReceiveRequest;
15945    }
15946
15947    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for DirReceiverReceiveRequest<T0>
15948    where
15949        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15950        ___E: ::fidl_next::fuchsia::HandleEncoder,
15951        T0: ::fidl_next::Encode<
15952                ___E,
15953                Encoded = ::fidl_next::ServerEnd<
15954                    ::fidl_next_fuchsia_io::Directory,
15955                    ::fidl_next::fuchsia::WireChannel,
15956                >,
15957            >,
15958    {
15959        #[inline]
15960        fn encode(
15961            self,
15962            encoder_: &mut ___E,
15963            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
15964            _: (),
15965        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
15966            ::fidl_next::munge! {
15967                let Self::Encoded {
15968
15969                    channel,
15970
15971                } = out_;
15972            }
15973
15974            ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
15975
15976            Ok(())
15977        }
15978    }
15979
15980    pub struct ProtocolPayload<T0> {
15981        pub channel: T0,
15982    }
15983
15984    impl<T0> ::fidl_next::Encodable for ProtocolPayload<T0>
15985    where
15986        T0: ::fidl_next::Encodable<Encoded = ::fidl_next::fuchsia::WireChannel>,
15987    {
15988        type Encoded = crate::wire::ProtocolPayload;
15989    }
15990
15991    unsafe impl<___E, T0> ::fidl_next::Encode<___E> for ProtocolPayload<T0>
15992    where
15993        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
15994        ___E: ::fidl_next::fuchsia::HandleEncoder,
15995        T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::fuchsia::WireChannel>,
15996    {
15997        #[inline]
15998        fn encode(
15999            self,
16000            encoder_: &mut ___E,
16001            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
16002            _: (),
16003        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16004            ::fidl_next::munge! {
16005                let Self::Encoded {
16006
16007                    channel,
16008
16009                } = out_;
16010            }
16011
16012            ::fidl_next::Encode::encode(self.channel, encoder_, channel, ())?;
16013
16014            Ok(())
16015        }
16016    }
16017
16018    pub struct Unavailable {}
16019
16020    impl ::fidl_next::Encodable for Unavailable {
16021        type Encoded = crate::wire::Unavailable;
16022    }
16023
16024    unsafe impl<___E> ::fidl_next::Encode<___E> for Unavailable
16025    where
16026        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16027    {
16028        #[inline]
16029        fn encode(
16030            self,
16031            encoder_: &mut ___E,
16032            out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
16033            _: (),
16034        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16035            ::fidl_next::munge! {
16036                let Self::Encoded {
16037
16038                        _empty,
16039
16040
16041                } = out_;
16042            }
16043
16044            Ok(())
16045        }
16046    }
16047}
16048
16049pub use self::natural::*;
16050
16051#[doc = " Maximum number of bytes in a [Data].\n"]
16052pub const MAX_DATA_LENGTH: u32 = 8192 as u32;
16053
16054#[doc = " The maximum length of a dictionary key. This should coincide with\n fuchsia.component.MAX_NAME_LENGTH.\n"]
16055pub const MAX_NAME_LENGTH: u64 = 255 as u64;
16056
16057/// The type corresponding to the CapabilityStore protocol.
16058#[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"]
16059#[derive(PartialEq, Debug)]
16060pub struct CapabilityStore;
16061
16062impl ::fidl_next::Discoverable for CapabilityStore {
16063    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.CapabilityStore";
16064}
16065
16066#[cfg(target_os = "fuchsia")]
16067impl ::fidl_next::HasTransport for CapabilityStore {
16068    type Transport = ::fidl_next::fuchsia::zx::Channel;
16069}
16070
16071pub mod capability_store {
16072    pub mod prelude {
16073        pub use crate::{
16074            CapabilityStore, CapabilityStoreClientHandler, CapabilityStoreServerHandler,
16075            capability_store,
16076        };
16077
16078        pub use crate::natural::CapabilityStoreConnectorCreateRequest;
16079
16080        pub use crate::natural::CapabilityStoreConnectorOpenRequest;
16081
16082        pub use crate::natural::CapabilityStoreDictionaryCopyRequest;
16083
16084        pub use crate::natural::CapabilityStoreDictionaryCreateRequest;
16085
16086        pub use crate::natural::CapabilityStoreDictionaryDrainRequest;
16087
16088        pub use crate::natural::CapabilityStoreDictionaryEnumerateRequest;
16089
16090        pub use crate::natural::CapabilityStoreDictionaryGetRequest;
16091
16092        pub use crate::natural::CapabilityStoreDictionaryInsertRequest;
16093
16094        pub use crate::natural::CapabilityStoreDictionaryKeysRequest;
16095
16096        pub use crate::natural::CapabilityStoreDictionaryLegacyExportRequest;
16097
16098        pub use crate::natural::CapabilityStoreDictionaryLegacyImportRequest;
16099
16100        pub use crate::natural::CapabilityStoreDictionaryRemoveRequest;
16101
16102        pub use crate::natural::CapabilityStoreDirConnectorCreateRequest;
16103
16104        pub use crate::natural::CapabilityStoreDirConnectorOpenRequest;
16105
16106        pub use crate::natural::CapabilityStoreDropRequest;
16107
16108        pub use crate::natural::CapabilityStoreDuplicateRequest;
16109
16110        pub use crate::natural::CapabilityStoreError;
16111
16112        pub use crate::natural::CapabilityStoreExportRequest;
16113
16114        pub use crate::natural::CapabilityStoreImportRequest;
16115
16116        pub use crate::natural::CapabilityStoreConnectorCreateResponse;
16117
16118        pub use crate::natural::CapabilityStoreConnectorOpenResponse;
16119
16120        pub use crate::natural::CapabilityStoreDictionaryCopyResponse;
16121
16122        pub use crate::natural::CapabilityStoreDictionaryCreateResponse;
16123
16124        pub use crate::natural::CapabilityStoreDictionaryDrainResponse;
16125
16126        pub use crate::natural::CapabilityStoreDictionaryEnumerateResponse;
16127
16128        pub use crate::natural::CapabilityStoreDictionaryGetResponse;
16129
16130        pub use crate::natural::CapabilityStoreDictionaryInsertResponse;
16131
16132        pub use crate::natural::CapabilityStoreDictionaryKeysResponse;
16133
16134        pub use crate::natural::CapabilityStoreDictionaryLegacyExportResponse;
16135
16136        pub use crate::natural::CapabilityStoreDictionaryLegacyImportResponse;
16137
16138        pub use crate::natural::CapabilityStoreDictionaryRemoveResponse;
16139
16140        pub use crate::natural::CapabilityStoreDirConnectorCreateResponse;
16141
16142        pub use crate::natural::CapabilityStoreDirConnectorOpenResponse;
16143
16144        pub use crate::natural::CapabilityStoreDropResponse;
16145
16146        pub use crate::natural::CapabilityStoreDuplicateResponse;
16147
16148        pub use crate::natural::CapabilityStoreExportResponse;
16149
16150        pub use crate::natural::CapabilityStoreImportResponse;
16151    }
16152
16153    pub struct Duplicate;
16154
16155    impl ::fidl_next::Method for Duplicate {
16156        const ORDINAL: u64 = 6727592627741008260;
16157        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16158            ::fidl_next::protocol::Flexibility::Flexible;
16159
16160        type Protocol = crate::CapabilityStore;
16161
16162        type Request = crate::wire::CapabilityStoreDuplicateRequest;
16163
16164        type Response = ::fidl_next::WireFlexibleResult<
16165            'static,
16166            crate::wire::CapabilityStoreDuplicateResponse,
16167            crate::wire::CapabilityStoreError,
16168        >;
16169    }
16170
16171    impl<___R> ::fidl_next::Respond<___R> for Duplicate {
16172        type Output = ::fidl_next::FlexibleResult<
16173            ___R,
16174            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16175        >;
16176
16177        fn respond(response: ___R) -> Self::Output {
16178            ::fidl_next::FlexibleResult::Ok(response)
16179        }
16180    }
16181
16182    impl<___R> ::fidl_next::RespondErr<___R> for Duplicate {
16183        type Output = ::fidl_next::FlexibleResult<
16184            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDuplicateResponse>,
16185            ___R,
16186        >;
16187
16188        fn respond_err(response: ___R) -> Self::Output {
16189            ::fidl_next::FlexibleResult::Err(response)
16190        }
16191    }
16192
16193    pub struct Drop;
16194
16195    impl ::fidl_next::Method for Drop {
16196        const ORDINAL: u64 = 753328233834620249;
16197        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16198            ::fidl_next::protocol::Flexibility::Flexible;
16199
16200        type Protocol = crate::CapabilityStore;
16201
16202        type Request = crate::wire::CapabilityStoreDropRequest;
16203
16204        type Response = ::fidl_next::WireFlexibleResult<
16205            'static,
16206            crate::wire::CapabilityStoreDropResponse,
16207            crate::wire::CapabilityStoreError,
16208        >;
16209    }
16210
16211    impl<___R> ::fidl_next::Respond<___R> for Drop {
16212        type Output = ::fidl_next::FlexibleResult<
16213            ___R,
16214            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16215        >;
16216
16217        fn respond(response: ___R) -> Self::Output {
16218            ::fidl_next::FlexibleResult::Ok(response)
16219        }
16220    }
16221
16222    impl<___R> ::fidl_next::RespondErr<___R> for Drop {
16223        type Output = ::fidl_next::FlexibleResult<
16224            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDropResponse>,
16225            ___R,
16226        >;
16227
16228        fn respond_err(response: ___R) -> Self::Output {
16229            ::fidl_next::FlexibleResult::Err(response)
16230        }
16231    }
16232
16233    pub struct Export;
16234
16235    impl ::fidl_next::Method for Export {
16236        const ORDINAL: u64 = 226159162093533951;
16237        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16238            ::fidl_next::protocol::Flexibility::Flexible;
16239
16240        type Protocol = crate::CapabilityStore;
16241
16242        type Request = crate::wire::CapabilityStoreExportRequest;
16243
16244        type Response = ::fidl_next::WireFlexibleResult<
16245            'static,
16246            crate::wire::CapabilityStoreExportResponse<'static>,
16247            crate::wire::CapabilityStoreError,
16248        >;
16249    }
16250
16251    impl<___R> ::fidl_next::Respond<___R> for Export {
16252        type Output = ::fidl_next::FlexibleResult<
16253            crate::generic::CapabilityStoreExportResponse<___R>,
16254            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16255        >;
16256
16257        fn respond(response: ___R) -> Self::Output {
16258            ::fidl_next::FlexibleResult::Ok(crate::generic::CapabilityStoreExportResponse {
16259                capability: response,
16260            })
16261        }
16262    }
16263
16264    impl<___R> ::fidl_next::RespondErr<___R> for Export {
16265        type Output = ::fidl_next::FlexibleResult<
16266            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreExportResponse<'static>>,
16267            ___R,
16268        >;
16269
16270        fn respond_err(response: ___R) -> Self::Output {
16271            ::fidl_next::FlexibleResult::Err(response)
16272        }
16273    }
16274
16275    pub struct Import;
16276
16277    impl ::fidl_next::Method for Import {
16278        const ORDINAL: u64 = 2276030276116435867;
16279        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16280            ::fidl_next::protocol::Flexibility::Flexible;
16281
16282        type Protocol = crate::CapabilityStore;
16283
16284        type Request = crate::wire::CapabilityStoreImportRequest<'static>;
16285
16286        type Response = ::fidl_next::WireFlexibleResult<
16287            'static,
16288            crate::wire::CapabilityStoreImportResponse,
16289            crate::wire::CapabilityStoreError,
16290        >;
16291    }
16292
16293    impl<___R> ::fidl_next::Respond<___R> for Import {
16294        type Output = ::fidl_next::FlexibleResult<
16295            ___R,
16296            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16297        >;
16298
16299        fn respond(response: ___R) -> Self::Output {
16300            ::fidl_next::FlexibleResult::Ok(response)
16301        }
16302    }
16303
16304    impl<___R> ::fidl_next::RespondErr<___R> for Import {
16305        type Output = ::fidl_next::FlexibleResult<
16306            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreImportResponse>,
16307            ___R,
16308        >;
16309
16310        fn respond_err(response: ___R) -> Self::Output {
16311            ::fidl_next::FlexibleResult::Err(response)
16312        }
16313    }
16314
16315    pub struct ConnectorCreate;
16316
16317    impl ::fidl_next::Method for ConnectorCreate {
16318        const ORDINAL: u64 = 2979461408102095909;
16319        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16320            ::fidl_next::protocol::Flexibility::Flexible;
16321
16322        type Protocol = crate::CapabilityStore;
16323
16324        type Request = crate::wire::CapabilityStoreConnectorCreateRequest;
16325
16326        type Response = ::fidl_next::WireFlexibleResult<
16327            'static,
16328            crate::wire::CapabilityStoreConnectorCreateResponse,
16329            crate::wire::CapabilityStoreError,
16330        >;
16331    }
16332
16333    impl<___R> ::fidl_next::Respond<___R> for ConnectorCreate {
16334        type Output = ::fidl_next::FlexibleResult<
16335            ___R,
16336            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16337        >;
16338
16339        fn respond(response: ___R) -> Self::Output {
16340            ::fidl_next::FlexibleResult::Ok(response)
16341        }
16342    }
16343
16344    impl<___R> ::fidl_next::RespondErr<___R> for ConnectorCreate {
16345        type Output = ::fidl_next::FlexibleResult<
16346            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreConnectorCreateResponse>,
16347            ___R,
16348        >;
16349
16350        fn respond_err(response: ___R) -> Self::Output {
16351            ::fidl_next::FlexibleResult::Err(response)
16352        }
16353    }
16354
16355    pub struct ConnectorOpen;
16356
16357    impl ::fidl_next::Method for ConnectorOpen {
16358        const ORDINAL: u64 = 6016362336453278623;
16359        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16360            ::fidl_next::protocol::Flexibility::Flexible;
16361
16362        type Protocol = crate::CapabilityStore;
16363
16364        type Request = crate::wire::CapabilityStoreConnectorOpenRequest;
16365
16366        type Response = ::fidl_next::WireFlexibleResult<
16367            'static,
16368            crate::wire::CapabilityStoreConnectorOpenResponse,
16369            crate::wire::CapabilityStoreError,
16370        >;
16371    }
16372
16373    impl<___R> ::fidl_next::Respond<___R> for ConnectorOpen {
16374        type Output = ::fidl_next::FlexibleResult<
16375            ___R,
16376            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16377        >;
16378
16379        fn respond(response: ___R) -> Self::Output {
16380            ::fidl_next::FlexibleResult::Ok(response)
16381        }
16382    }
16383
16384    impl<___R> ::fidl_next::RespondErr<___R> for ConnectorOpen {
16385        type Output = ::fidl_next::FlexibleResult<
16386            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreConnectorOpenResponse>,
16387            ___R,
16388        >;
16389
16390        fn respond_err(response: ___R) -> Self::Output {
16391            ::fidl_next::FlexibleResult::Err(response)
16392        }
16393    }
16394
16395    pub struct DirConnectorCreate;
16396
16397    impl ::fidl_next::Method for DirConnectorCreate {
16398        const ORDINAL: u64 = 1756747594275428795;
16399        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16400            ::fidl_next::protocol::Flexibility::Flexible;
16401
16402        type Protocol = crate::CapabilityStore;
16403
16404        type Request = crate::wire::CapabilityStoreDirConnectorCreateRequest;
16405
16406        type Response = ::fidl_next::WireFlexibleResult<
16407            'static,
16408            crate::wire::CapabilityStoreDirConnectorCreateResponse,
16409            crate::wire::CapabilityStoreError,
16410        >;
16411    }
16412
16413    impl<___R> ::fidl_next::Respond<___R> for DirConnectorCreate {
16414        type Output = ::fidl_next::FlexibleResult<
16415            ___R,
16416            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16417        >;
16418
16419        fn respond(response: ___R) -> Self::Output {
16420            ::fidl_next::FlexibleResult::Ok(response)
16421        }
16422    }
16423
16424    impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorCreate {
16425        type Output = ::fidl_next::FlexibleResult<
16426            ::fidl_next::util::EncodableNever<
16427                crate::wire::CapabilityStoreDirConnectorCreateResponse,
16428            >,
16429            ___R,
16430        >;
16431
16432        fn respond_err(response: ___R) -> Self::Output {
16433            ::fidl_next::FlexibleResult::Err(response)
16434        }
16435    }
16436
16437    pub struct DirConnectorOpen;
16438
16439    impl ::fidl_next::Method for DirConnectorOpen {
16440        const ORDINAL: u64 = 6219704004220369153;
16441        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16442            ::fidl_next::protocol::Flexibility::Flexible;
16443
16444        type Protocol = crate::CapabilityStore;
16445
16446        type Request = crate::wire::CapabilityStoreDirConnectorOpenRequest;
16447
16448        type Response = ::fidl_next::WireFlexibleResult<
16449            'static,
16450            crate::wire::CapabilityStoreDirConnectorOpenResponse,
16451            crate::wire::CapabilityStoreError,
16452        >;
16453    }
16454
16455    impl<___R> ::fidl_next::Respond<___R> for DirConnectorOpen {
16456        type Output = ::fidl_next::FlexibleResult<
16457            ___R,
16458            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16459        >;
16460
16461        fn respond(response: ___R) -> Self::Output {
16462            ::fidl_next::FlexibleResult::Ok(response)
16463        }
16464    }
16465
16466    impl<___R> ::fidl_next::RespondErr<___R> for DirConnectorOpen {
16467        type Output = ::fidl_next::FlexibleResult<
16468            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDirConnectorOpenResponse>,
16469            ___R,
16470        >;
16471
16472        fn respond_err(response: ___R) -> Self::Output {
16473            ::fidl_next::FlexibleResult::Err(response)
16474        }
16475    }
16476
16477    pub struct DictionaryCreate;
16478
16479    impl ::fidl_next::Method for DictionaryCreate {
16480        const ORDINAL: u64 = 7608770958894948499;
16481        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16482            ::fidl_next::protocol::Flexibility::Flexible;
16483
16484        type Protocol = crate::CapabilityStore;
16485
16486        type Request = crate::wire::CapabilityStoreDictionaryCreateRequest;
16487
16488        type Response = ::fidl_next::WireFlexibleResult<
16489            'static,
16490            crate::wire::CapabilityStoreDictionaryCreateResponse,
16491            crate::wire::CapabilityStoreError,
16492        >;
16493    }
16494
16495    impl<___R> ::fidl_next::Respond<___R> for DictionaryCreate {
16496        type Output = ::fidl_next::FlexibleResult<
16497            ___R,
16498            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16499        >;
16500
16501        fn respond(response: ___R) -> Self::Output {
16502            ::fidl_next::FlexibleResult::Ok(response)
16503        }
16504    }
16505
16506    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCreate {
16507        type Output = ::fidl_next::FlexibleResult<
16508            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryCreateResponse>,
16509            ___R,
16510        >;
16511
16512        fn respond_err(response: ___R) -> Self::Output {
16513            ::fidl_next::FlexibleResult::Err(response)
16514        }
16515    }
16516
16517    pub struct DictionaryLegacyImport;
16518
16519    impl ::fidl_next::Method for DictionaryLegacyImport {
16520        const ORDINAL: u64 = 8285893703432012383;
16521        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16522            ::fidl_next::protocol::Flexibility::Flexible;
16523
16524        type Protocol = crate::CapabilityStore;
16525
16526        type Request = crate::wire::CapabilityStoreDictionaryLegacyImportRequest;
16527
16528        type Response = ::fidl_next::WireFlexibleResult<
16529            'static,
16530            crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
16531            crate::wire::CapabilityStoreError,
16532        >;
16533    }
16534
16535    impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyImport {
16536        type Output = ::fidl_next::FlexibleResult<
16537            ___R,
16538            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16539        >;
16540
16541        fn respond(response: ___R) -> Self::Output {
16542            ::fidl_next::FlexibleResult::Ok(response)
16543        }
16544    }
16545
16546    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyImport {
16547        type Output = ::fidl_next::FlexibleResult<
16548            ::fidl_next::util::EncodableNever<
16549                crate::wire::CapabilityStoreDictionaryLegacyImportResponse,
16550            >,
16551            ___R,
16552        >;
16553
16554        fn respond_err(response: ___R) -> Self::Output {
16555            ::fidl_next::FlexibleResult::Err(response)
16556        }
16557    }
16558
16559    pub struct DictionaryLegacyExport;
16560
16561    impl ::fidl_next::Method for DictionaryLegacyExport {
16562        const ORDINAL: u64 = 4647175832683306445;
16563        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16564            ::fidl_next::protocol::Flexibility::Flexible;
16565
16566        type Protocol = crate::CapabilityStore;
16567
16568        type Request = crate::wire::CapabilityStoreDictionaryLegacyExportRequest;
16569
16570        type Response = ::fidl_next::WireFlexibleResult<
16571            'static,
16572            crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
16573            crate::wire::CapabilityStoreError,
16574        >;
16575    }
16576
16577    impl<___R> ::fidl_next::Respond<___R> for DictionaryLegacyExport {
16578        type Output = ::fidl_next::FlexibleResult<
16579            ___R,
16580            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16581        >;
16582
16583        fn respond(response: ___R) -> Self::Output {
16584            ::fidl_next::FlexibleResult::Ok(response)
16585        }
16586    }
16587
16588    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryLegacyExport {
16589        type Output = ::fidl_next::FlexibleResult<
16590            ::fidl_next::util::EncodableNever<
16591                crate::wire::CapabilityStoreDictionaryLegacyExportResponse,
16592            >,
16593            ___R,
16594        >;
16595
16596        fn respond_err(response: ___R) -> Self::Output {
16597            ::fidl_next::FlexibleResult::Err(response)
16598        }
16599    }
16600
16601    pub struct DictionaryInsert;
16602
16603    impl ::fidl_next::Method for DictionaryInsert {
16604        const ORDINAL: u64 = 8575443262986538023;
16605        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16606            ::fidl_next::protocol::Flexibility::Flexible;
16607
16608        type Protocol = crate::CapabilityStore;
16609
16610        type Request = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>;
16611
16612        type Response = ::fidl_next::WireFlexibleResult<
16613            'static,
16614            crate::wire::CapabilityStoreDictionaryInsertResponse,
16615            crate::wire::CapabilityStoreError,
16616        >;
16617    }
16618
16619    impl<___R> ::fidl_next::Respond<___R> for DictionaryInsert {
16620        type Output = ::fidl_next::FlexibleResult<
16621            ___R,
16622            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16623        >;
16624
16625        fn respond(response: ___R) -> Self::Output {
16626            ::fidl_next::FlexibleResult::Ok(response)
16627        }
16628    }
16629
16630    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryInsert {
16631        type Output = ::fidl_next::FlexibleResult<
16632            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryInsertResponse>,
16633            ___R,
16634        >;
16635
16636        fn respond_err(response: ___R) -> Self::Output {
16637            ::fidl_next::FlexibleResult::Err(response)
16638        }
16639    }
16640
16641    pub struct DictionaryGet;
16642
16643    impl ::fidl_next::Method for DictionaryGet {
16644        const ORDINAL: u64 = 5592951026866236882;
16645        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16646            ::fidl_next::protocol::Flexibility::Flexible;
16647
16648        type Protocol = crate::CapabilityStore;
16649
16650        type Request = crate::wire::CapabilityStoreDictionaryGetRequest<'static>;
16651
16652        type Response = ::fidl_next::WireFlexibleResult<
16653            'static,
16654            crate::wire::CapabilityStoreDictionaryGetResponse,
16655            crate::wire::CapabilityStoreError,
16656        >;
16657    }
16658
16659    impl<___R> ::fidl_next::Respond<___R> for DictionaryGet {
16660        type Output = ::fidl_next::FlexibleResult<
16661            ___R,
16662            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16663        >;
16664
16665        fn respond(response: ___R) -> Self::Output {
16666            ::fidl_next::FlexibleResult::Ok(response)
16667        }
16668    }
16669
16670    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryGet {
16671        type Output = ::fidl_next::FlexibleResult<
16672            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryGetResponse>,
16673            ___R,
16674        >;
16675
16676        fn respond_err(response: ___R) -> Self::Output {
16677            ::fidl_next::FlexibleResult::Err(response)
16678        }
16679    }
16680
16681    pub struct DictionaryRemove;
16682
16683    impl ::fidl_next::Method for DictionaryRemove {
16684        const ORDINAL: u64 = 343892214579320051;
16685        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16686            ::fidl_next::protocol::Flexibility::Flexible;
16687
16688        type Protocol = crate::CapabilityStore;
16689
16690        type Request = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>;
16691
16692        type Response = ::fidl_next::WireFlexibleResult<
16693            'static,
16694            crate::wire::CapabilityStoreDictionaryRemoveResponse,
16695            crate::wire::CapabilityStoreError,
16696        >;
16697    }
16698
16699    impl<___R> ::fidl_next::Respond<___R> for DictionaryRemove {
16700        type Output = ::fidl_next::FlexibleResult<
16701            ___R,
16702            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16703        >;
16704
16705        fn respond(response: ___R) -> Self::Output {
16706            ::fidl_next::FlexibleResult::Ok(response)
16707        }
16708    }
16709
16710    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryRemove {
16711        type Output = ::fidl_next::FlexibleResult<
16712            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryRemoveResponse>,
16713            ___R,
16714        >;
16715
16716        fn respond_err(response: ___R) -> Self::Output {
16717            ::fidl_next::FlexibleResult::Err(response)
16718        }
16719    }
16720
16721    pub struct DictionaryCopy;
16722
16723    impl ::fidl_next::Method for DictionaryCopy {
16724        const ORDINAL: u64 = 3977783339739362383;
16725        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16726            ::fidl_next::protocol::Flexibility::Flexible;
16727
16728        type Protocol = crate::CapabilityStore;
16729
16730        type Request = crate::wire::CapabilityStoreDictionaryCopyRequest;
16731
16732        type Response = ::fidl_next::WireFlexibleResult<
16733            'static,
16734            crate::wire::CapabilityStoreDictionaryCopyResponse,
16735            crate::wire::CapabilityStoreError,
16736        >;
16737    }
16738
16739    impl<___R> ::fidl_next::Respond<___R> for DictionaryCopy {
16740        type Output = ::fidl_next::FlexibleResult<
16741            ___R,
16742            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16743        >;
16744
16745        fn respond(response: ___R) -> Self::Output {
16746            ::fidl_next::FlexibleResult::Ok(response)
16747        }
16748    }
16749
16750    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryCopy {
16751        type Output = ::fidl_next::FlexibleResult<
16752            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryCopyResponse>,
16753            ___R,
16754        >;
16755
16756        fn respond_err(response: ___R) -> Self::Output {
16757            ::fidl_next::FlexibleResult::Err(response)
16758        }
16759    }
16760
16761    pub struct DictionaryKeys;
16762
16763    impl ::fidl_next::Method for DictionaryKeys {
16764        const ORDINAL: u64 = 597577248872787102;
16765        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16766            ::fidl_next::protocol::Flexibility::Flexible;
16767
16768        type Protocol = crate::CapabilityStore;
16769
16770        type Request = crate::wire::CapabilityStoreDictionaryKeysRequest;
16771
16772        type Response = ::fidl_next::WireFlexibleResult<
16773            'static,
16774            crate::wire::CapabilityStoreDictionaryKeysResponse,
16775            crate::wire::CapabilityStoreError,
16776        >;
16777    }
16778
16779    impl<___R> ::fidl_next::Respond<___R> for DictionaryKeys {
16780        type Output = ::fidl_next::FlexibleResult<
16781            ___R,
16782            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16783        >;
16784
16785        fn respond(response: ___R) -> Self::Output {
16786            ::fidl_next::FlexibleResult::Ok(response)
16787        }
16788    }
16789
16790    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryKeys {
16791        type Output = ::fidl_next::FlexibleResult<
16792            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryKeysResponse>,
16793            ___R,
16794        >;
16795
16796        fn respond_err(response: ___R) -> Self::Output {
16797            ::fidl_next::FlexibleResult::Err(response)
16798        }
16799    }
16800
16801    pub struct DictionaryEnumerate;
16802
16803    impl ::fidl_next::Method for DictionaryEnumerate {
16804        const ORDINAL: u64 = 964467096271472193;
16805        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16806            ::fidl_next::protocol::Flexibility::Flexible;
16807
16808        type Protocol = crate::CapabilityStore;
16809
16810        type Request = crate::wire::CapabilityStoreDictionaryEnumerateRequest;
16811
16812        type Response = ::fidl_next::WireFlexibleResult<
16813            'static,
16814            crate::wire::CapabilityStoreDictionaryEnumerateResponse,
16815            crate::wire::CapabilityStoreError,
16816        >;
16817    }
16818
16819    impl<___R> ::fidl_next::Respond<___R> for DictionaryEnumerate {
16820        type Output = ::fidl_next::FlexibleResult<
16821            ___R,
16822            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16823        >;
16824
16825        fn respond(response: ___R) -> Self::Output {
16826            ::fidl_next::FlexibleResult::Ok(response)
16827        }
16828    }
16829
16830    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryEnumerate {
16831        type Output = ::fidl_next::FlexibleResult<
16832            ::fidl_next::util::EncodableNever<
16833                crate::wire::CapabilityStoreDictionaryEnumerateResponse,
16834            >,
16835            ___R,
16836        >;
16837
16838        fn respond_err(response: ___R) -> Self::Output {
16839            ::fidl_next::FlexibleResult::Err(response)
16840        }
16841    }
16842
16843    pub struct DictionaryDrain;
16844
16845    impl ::fidl_next::Method for DictionaryDrain {
16846        const ORDINAL: u64 = 2928364469569621208;
16847        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
16848            ::fidl_next::protocol::Flexibility::Flexible;
16849
16850        type Protocol = crate::CapabilityStore;
16851
16852        type Request = crate::wire::CapabilityStoreDictionaryDrainRequest;
16853
16854        type Response = ::fidl_next::WireFlexibleResult<
16855            'static,
16856            crate::wire::CapabilityStoreDictionaryDrainResponse,
16857            crate::wire::CapabilityStoreError,
16858        >;
16859    }
16860
16861    impl<___R> ::fidl_next::Respond<___R> for DictionaryDrain {
16862        type Output = ::fidl_next::FlexibleResult<
16863            ___R,
16864            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
16865        >;
16866
16867        fn respond(response: ___R) -> Self::Output {
16868            ::fidl_next::FlexibleResult::Ok(response)
16869        }
16870    }
16871
16872    impl<___R> ::fidl_next::RespondErr<___R> for DictionaryDrain {
16873        type Output = ::fidl_next::FlexibleResult<
16874            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreDictionaryDrainResponse>,
16875            ___R,
16876        >;
16877
16878        fn respond_err(response: ___R) -> Self::Output {
16879            ::fidl_next::FlexibleResult::Err(response)
16880        }
16881    }
16882
16883    mod ___detail {
16884        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::CapabilityStore
16885        where
16886            ___T: ::fidl_next::Transport,
16887        {
16888            type Client = CapabilityStoreClient<___T>;
16889            type Server = CapabilityStoreServer<___T>;
16890        }
16891
16892        /// The client for the `CapabilityStore` protocol.
16893        #[repr(transparent)]
16894        pub struct CapabilityStoreClient<___T: ::fidl_next::Transport> {
16895            #[allow(dead_code)]
16896            client: ::fidl_next::protocol::Client<___T>,
16897        }
16898
16899        impl<___T> CapabilityStoreClient<___T>
16900        where
16901            ___T: ::fidl_next::Transport,
16902        {
16903            #[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"]
16904            pub fn duplicate(
16905                &self,
16906
16907                id: impl ::fidl_next::Encode<
16908                    <___T as ::fidl_next::Transport>::SendBuffer,
16909                    Encoded = ::fidl_next::WireU64,
16910                >,
16911
16912                dest_id: impl ::fidl_next::Encode<
16913                    <___T as ::fidl_next::Transport>::SendBuffer,
16914                    Encoded = ::fidl_next::WireU64,
16915                >,
16916            ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
16917            where
16918                <___T as ::fidl_next::Transport>::SendBuffer:
16919                    ::fidl_next::encoder::InternalHandleEncoder,
16920            {
16921                self.duplicate_with(crate::generic::CapabilityStoreDuplicateRequest { id, dest_id })
16922            }
16923
16924            #[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"]
16925            pub fn duplicate_with<___R>(
16926                &self,
16927                request: ___R,
16928            ) -> ::fidl_next::TwoWayFuture<'_, super::Duplicate, ___T>
16929            where
16930                ___R: ::fidl_next::Encode<
16931                        <___T as ::fidl_next::Transport>::SendBuffer,
16932                        Encoded = crate::wire::CapabilityStoreDuplicateRequest,
16933                    >,
16934            {
16935                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
16936                    6727592627741008260,
16937                    <super::Duplicate as ::fidl_next::Method>::FLEXIBILITY,
16938                    request,
16939                ))
16940            }
16941
16942            #[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"]
16943            pub fn drop(
16944                &self,
16945
16946                id: impl ::fidl_next::Encode<
16947                    <___T as ::fidl_next::Transport>::SendBuffer,
16948                    Encoded = ::fidl_next::WireU64,
16949                >,
16950            ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
16951            where
16952                <___T as ::fidl_next::Transport>::SendBuffer:
16953                    ::fidl_next::encoder::InternalHandleEncoder,
16954            {
16955                self.drop_with(crate::generic::CapabilityStoreDropRequest { id })
16956            }
16957
16958            #[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"]
16959            pub fn drop_with<___R>(
16960                &self,
16961                request: ___R,
16962            ) -> ::fidl_next::TwoWayFuture<'_, super::Drop, ___T>
16963            where
16964                ___R: ::fidl_next::Encode<
16965                        <___T as ::fidl_next::Transport>::SendBuffer,
16966                        Encoded = crate::wire::CapabilityStoreDropRequest,
16967                    >,
16968            {
16969                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
16970                    753328233834620249,
16971                    <super::Drop as ::fidl_next::Method>::FLEXIBILITY,
16972                    request,
16973                ))
16974            }
16975
16976            #[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"]
16977            pub fn export(
16978                &self,
16979
16980                id: impl ::fidl_next::Encode<
16981                    <___T as ::fidl_next::Transport>::SendBuffer,
16982                    Encoded = ::fidl_next::WireU64,
16983                >,
16984            ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
16985            where
16986                <___T as ::fidl_next::Transport>::SendBuffer:
16987                    ::fidl_next::encoder::InternalHandleEncoder,
16988            {
16989                self.export_with(crate::generic::CapabilityStoreExportRequest { id })
16990            }
16991
16992            #[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"]
16993            pub fn export_with<___R>(
16994                &self,
16995                request: ___R,
16996            ) -> ::fidl_next::TwoWayFuture<'_, super::Export, ___T>
16997            where
16998                ___R: ::fidl_next::Encode<
16999                        <___T as ::fidl_next::Transport>::SendBuffer,
17000                        Encoded = crate::wire::CapabilityStoreExportRequest,
17001                    >,
17002            {
17003                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17004                    226159162093533951,
17005                    <super::Export as ::fidl_next::Method>::FLEXIBILITY,
17006                    request,
17007                ))
17008            }
17009
17010            #[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"]
17011            pub fn import(
17012                &self,
17013
17014                id: impl ::fidl_next::Encode<
17015                    <___T as ::fidl_next::Transport>::SendBuffer,
17016                    Encoded = ::fidl_next::WireU64,
17017                >,
17018
17019                capability: impl ::fidl_next::Encode<
17020                    <___T as ::fidl_next::Transport>::SendBuffer,
17021                    Encoded = crate::wire::Capability<'static>,
17022                >,
17023            ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
17024            where
17025                <___T as ::fidl_next::Transport>::SendBuffer:
17026                    ::fidl_next::encoder::InternalHandleEncoder,
17027                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17028                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17029            {
17030                self.import_with(crate::generic::CapabilityStoreImportRequest { id, capability })
17031            }
17032
17033            #[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"]
17034            pub fn import_with<___R>(
17035                &self,
17036                request: ___R,
17037            ) -> ::fidl_next::TwoWayFuture<'_, super::Import, ___T>
17038            where
17039                ___R: ::fidl_next::Encode<
17040                        <___T as ::fidl_next::Transport>::SendBuffer,
17041                        Encoded = crate::wire::CapabilityStoreImportRequest<'static>,
17042                    >,
17043            {
17044                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17045                    2276030276116435867,
17046                    <super::Import as ::fidl_next::Method>::FLEXIBILITY,
17047                    request,
17048                ))
17049            }
17050
17051            #[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"]
17052            pub fn connector_create(
17053                &self,
17054
17055                id: impl ::fidl_next::Encode<
17056                    <___T as ::fidl_next::Transport>::SendBuffer,
17057                    Encoded = ::fidl_next::WireU64,
17058                >,
17059
17060                receiver: impl ::fidl_next::Encode<
17061                    <___T as ::fidl_next::Transport>::SendBuffer,
17062                    Encoded = ::fidl_next::ClientEnd<
17063                        crate::Receiver,
17064                        ::fidl_next::fuchsia::WireChannel,
17065                    >,
17066                >,
17067            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
17068            where
17069                <___T as ::fidl_next::Transport>::SendBuffer:
17070                    ::fidl_next::encoder::InternalHandleEncoder,
17071                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17072            {
17073                self.connector_create_with(crate::generic::CapabilityStoreConnectorCreateRequest {
17074                    id,
17075
17076                    receiver,
17077                })
17078            }
17079
17080            #[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"]
17081            pub fn connector_create_with<___R>(
17082                &self,
17083                request: ___R,
17084            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorCreate, ___T>
17085            where
17086                ___R: ::fidl_next::Encode<
17087                        <___T as ::fidl_next::Transport>::SendBuffer,
17088                        Encoded = crate::wire::CapabilityStoreConnectorCreateRequest,
17089                    >,
17090            {
17091                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17092                    2979461408102095909,
17093                    <super::ConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
17094                    request,
17095                ))
17096            }
17097
17098            #[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"]
17099            pub fn connector_open(
17100                &self,
17101
17102                id: impl ::fidl_next::Encode<
17103                    <___T as ::fidl_next::Transport>::SendBuffer,
17104                    Encoded = ::fidl_next::WireU64,
17105                >,
17106
17107                server_end: impl ::fidl_next::Encode<
17108                    <___T as ::fidl_next::Transport>::SendBuffer,
17109                    Encoded = ::fidl_next::fuchsia::WireChannel,
17110                >,
17111            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
17112            where
17113                <___T as ::fidl_next::Transport>::SendBuffer:
17114                    ::fidl_next::encoder::InternalHandleEncoder,
17115                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17116            {
17117                self.connector_open_with(crate::generic::CapabilityStoreConnectorOpenRequest {
17118                    id,
17119
17120                    server_end,
17121                })
17122            }
17123
17124            #[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"]
17125            pub fn connector_open_with<___R>(
17126                &self,
17127                request: ___R,
17128            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectorOpen, ___T>
17129            where
17130                ___R: ::fidl_next::Encode<
17131                        <___T as ::fidl_next::Transport>::SendBuffer,
17132                        Encoded = crate::wire::CapabilityStoreConnectorOpenRequest,
17133                    >,
17134            {
17135                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17136                    6016362336453278623,
17137                    <super::ConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
17138                    request,
17139                ))
17140            }
17141
17142            #[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"]
17143            pub fn dir_connector_create(
17144                &self,
17145
17146                id: impl ::fidl_next::Encode<
17147                    <___T as ::fidl_next::Transport>::SendBuffer,
17148                    Encoded = ::fidl_next::WireU64,
17149                >,
17150
17151                receiver: impl ::fidl_next::Encode<
17152                    <___T as ::fidl_next::Transport>::SendBuffer,
17153                    Encoded = ::fidl_next::ClientEnd<
17154                        crate::DirReceiver,
17155                        ::fidl_next::fuchsia::WireChannel,
17156                    >,
17157                >,
17158            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
17159            where
17160                <___T as ::fidl_next::Transport>::SendBuffer:
17161                    ::fidl_next::encoder::InternalHandleEncoder,
17162                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17163            {
17164                self.dir_connector_create_with(
17165                    crate::generic::CapabilityStoreDirConnectorCreateRequest { id, receiver },
17166                )
17167            }
17168
17169            #[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"]
17170            pub fn dir_connector_create_with<___R>(
17171                &self,
17172                request: ___R,
17173            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorCreate, ___T>
17174            where
17175                ___R: ::fidl_next::Encode<
17176                        <___T as ::fidl_next::Transport>::SendBuffer,
17177                        Encoded = crate::wire::CapabilityStoreDirConnectorCreateRequest,
17178                    >,
17179            {
17180                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17181                    1756747594275428795,
17182                    <super::DirConnectorCreate as ::fidl_next::Method>::FLEXIBILITY,
17183                    request,
17184                ))
17185            }
17186
17187            #[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"]
17188            pub fn dir_connector_open(
17189                &self,
17190
17191                id: impl ::fidl_next::Encode<
17192                    <___T as ::fidl_next::Transport>::SendBuffer,
17193                    Encoded = ::fidl_next::WireU64,
17194                >,
17195
17196                server_end: impl ::fidl_next::Encode<
17197                    <___T as ::fidl_next::Transport>::SendBuffer,
17198                    Encoded = ::fidl_next::ServerEnd<
17199                        ::fidl_next_fuchsia_io::Directory,
17200                        ::fidl_next::fuchsia::WireChannel,
17201                    >,
17202                >,
17203            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
17204            where
17205                <___T as ::fidl_next::Transport>::SendBuffer:
17206                    ::fidl_next::encoder::InternalHandleEncoder,
17207                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17208            {
17209                self.dir_connector_open_with(
17210                    crate::generic::CapabilityStoreDirConnectorOpenRequest { id, server_end },
17211                )
17212            }
17213
17214            #[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"]
17215            pub fn dir_connector_open_with<___R>(
17216                &self,
17217                request: ___R,
17218            ) -> ::fidl_next::TwoWayFuture<'_, super::DirConnectorOpen, ___T>
17219            where
17220                ___R: ::fidl_next::Encode<
17221                        <___T as ::fidl_next::Transport>::SendBuffer,
17222                        Encoded = crate::wire::CapabilityStoreDirConnectorOpenRequest,
17223                    >,
17224            {
17225                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17226                    6219704004220369153,
17227                    <super::DirConnectorOpen as ::fidl_next::Method>::FLEXIBILITY,
17228                    request,
17229                ))
17230            }
17231
17232            #[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"]
17233            pub fn dictionary_create(
17234                &self,
17235
17236                id: impl ::fidl_next::Encode<
17237                    <___T as ::fidl_next::Transport>::SendBuffer,
17238                    Encoded = ::fidl_next::WireU64,
17239                >,
17240            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
17241            where
17242                <___T as ::fidl_next::Transport>::SendBuffer:
17243                    ::fidl_next::encoder::InternalHandleEncoder,
17244            {
17245                self.dictionary_create_with(
17246                    crate::generic::CapabilityStoreDictionaryCreateRequest { id },
17247                )
17248            }
17249
17250            #[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"]
17251            pub fn dictionary_create_with<___R>(
17252                &self,
17253                request: ___R,
17254            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCreate, ___T>
17255            where
17256                ___R: ::fidl_next::Encode<
17257                        <___T as ::fidl_next::Transport>::SendBuffer,
17258                        Encoded = crate::wire::CapabilityStoreDictionaryCreateRequest,
17259                    >,
17260            {
17261                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17262                    7608770958894948499,
17263                    <super::DictionaryCreate as ::fidl_next::Method>::FLEXIBILITY,
17264                    request,
17265                ))
17266            }
17267
17268            #[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"]
17269            pub fn dictionary_legacy_import(
17270                &self,
17271
17272                id: impl ::fidl_next::Encode<
17273                    <___T as ::fidl_next::Transport>::SendBuffer,
17274                    Encoded = ::fidl_next::WireU64,
17275                >,
17276
17277                client_end: impl ::fidl_next::Encode<
17278                    <___T as ::fidl_next::Transport>::SendBuffer,
17279                    Encoded = ::fidl_next::fuchsia::WireChannel,
17280                >,
17281            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
17282            where
17283                <___T as ::fidl_next::Transport>::SendBuffer:
17284                    ::fidl_next::encoder::InternalHandleEncoder,
17285                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17286            {
17287                self.dictionary_legacy_import_with(
17288                    crate::generic::CapabilityStoreDictionaryLegacyImportRequest { id, client_end },
17289                )
17290            }
17291
17292            #[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"]
17293            pub fn dictionary_legacy_import_with<___R>(
17294                &self,
17295                request: ___R,
17296            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyImport, ___T>
17297            where
17298                ___R: ::fidl_next::Encode<
17299                        <___T as ::fidl_next::Transport>::SendBuffer,
17300                        Encoded = crate::wire::CapabilityStoreDictionaryLegacyImportRequest,
17301                    >,
17302            {
17303                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17304                    8285893703432012383,
17305                    <super::DictionaryLegacyImport as ::fidl_next::Method>::FLEXIBILITY,
17306                    request,
17307                ))
17308            }
17309
17310            #[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"]
17311            pub fn dictionary_legacy_export(
17312                &self,
17313
17314                id: impl ::fidl_next::Encode<
17315                    <___T as ::fidl_next::Transport>::SendBuffer,
17316                    Encoded = ::fidl_next::WireU64,
17317                >,
17318
17319                server_end: impl ::fidl_next::Encode<
17320                    <___T as ::fidl_next::Transport>::SendBuffer,
17321                    Encoded = ::fidl_next::fuchsia::WireChannel,
17322                >,
17323            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
17324            where
17325                <___T as ::fidl_next::Transport>::SendBuffer:
17326                    ::fidl_next::encoder::InternalHandleEncoder,
17327                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17328            {
17329                self.dictionary_legacy_export_with(
17330                    crate::generic::CapabilityStoreDictionaryLegacyExportRequest { id, server_end },
17331                )
17332            }
17333
17334            #[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"]
17335            pub fn dictionary_legacy_export_with<___R>(
17336                &self,
17337                request: ___R,
17338            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryLegacyExport, ___T>
17339            where
17340                ___R: ::fidl_next::Encode<
17341                        <___T as ::fidl_next::Transport>::SendBuffer,
17342                        Encoded = crate::wire::CapabilityStoreDictionaryLegacyExportRequest,
17343                    >,
17344            {
17345                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17346                    4647175832683306445,
17347                    <super::DictionaryLegacyExport as ::fidl_next::Method>::FLEXIBILITY,
17348                    request,
17349                ))
17350            }
17351
17352            #[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"]
17353            pub fn dictionary_insert(
17354                &self,
17355
17356                id: impl ::fidl_next::Encode<
17357                    <___T as ::fidl_next::Transport>::SendBuffer,
17358                    Encoded = ::fidl_next::WireU64,
17359                >,
17360
17361                item: impl ::fidl_next::Encode<
17362                    <___T as ::fidl_next::Transport>::SendBuffer,
17363                    Encoded = crate::wire::DictionaryItem<'static>,
17364                >,
17365            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
17366            where
17367                <___T as ::fidl_next::Transport>::SendBuffer:
17368                    ::fidl_next::encoder::InternalHandleEncoder,
17369                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17370            {
17371                self.dictionary_insert_with(
17372                    crate::generic::CapabilityStoreDictionaryInsertRequest { id, item },
17373                )
17374            }
17375
17376            #[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"]
17377            pub fn dictionary_insert_with<___R>(
17378                &self,
17379                request: ___R,
17380            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryInsert, ___T>
17381            where
17382                ___R: ::fidl_next::Encode<
17383                        <___T as ::fidl_next::Transport>::SendBuffer,
17384                        Encoded = crate::wire::CapabilityStoreDictionaryInsertRequest<'static>,
17385                    >,
17386            {
17387                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17388                    8575443262986538023,
17389                    <super::DictionaryInsert as ::fidl_next::Method>::FLEXIBILITY,
17390                    request,
17391                ))
17392            }
17393
17394            #[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"]
17395            pub fn dictionary_get(
17396                &self,
17397
17398                id: impl ::fidl_next::Encode<
17399                    <___T as ::fidl_next::Transport>::SendBuffer,
17400                    Encoded = ::fidl_next::WireU64,
17401                >,
17402
17403                key: impl ::fidl_next::Encode<
17404                    <___T as ::fidl_next::Transport>::SendBuffer,
17405                    Encoded = ::fidl_next::WireString<'static>,
17406                >,
17407
17408                dest_id: impl ::fidl_next::Encode<
17409                    <___T as ::fidl_next::Transport>::SendBuffer,
17410                    Encoded = ::fidl_next::WireU64,
17411                >,
17412            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
17413            where
17414                <___T as ::fidl_next::Transport>::SendBuffer:
17415                    ::fidl_next::encoder::InternalHandleEncoder,
17416                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17417            {
17418                self.dictionary_get_with(crate::generic::CapabilityStoreDictionaryGetRequest {
17419                    id,
17420
17421                    key,
17422
17423                    dest_id,
17424                })
17425            }
17426
17427            #[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"]
17428            pub fn dictionary_get_with<___R>(
17429                &self,
17430                request: ___R,
17431            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryGet, ___T>
17432            where
17433                ___R: ::fidl_next::Encode<
17434                        <___T as ::fidl_next::Transport>::SendBuffer,
17435                        Encoded = crate::wire::CapabilityStoreDictionaryGetRequest<'static>,
17436                    >,
17437            {
17438                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17439                    5592951026866236882,
17440                    <super::DictionaryGet as ::fidl_next::Method>::FLEXIBILITY,
17441                    request,
17442                ))
17443            }
17444
17445            #[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"]
17446            pub fn dictionary_remove(
17447                &self,
17448
17449                id: impl ::fidl_next::Encode<
17450                    <___T as ::fidl_next::Transport>::SendBuffer,
17451                    Encoded = ::fidl_next::WireU64,
17452                >,
17453
17454                key: impl ::fidl_next::Encode<
17455                    <___T as ::fidl_next::Transport>::SendBuffer,
17456                    Encoded = ::fidl_next::WireString<'static>,
17457                >,
17458
17459                dest_id: impl ::fidl_next::Encode<
17460                    <___T as ::fidl_next::Transport>::SendBuffer,
17461                    Encoded = ::fidl_next::WireBox<'static, crate::wire::WrappedCapabilityId>,
17462                >,
17463            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
17464            where
17465                <___T as ::fidl_next::Transport>::SendBuffer:
17466                    ::fidl_next::encoder::InternalHandleEncoder,
17467                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17468            {
17469                self.dictionary_remove_with(
17470                    crate::generic::CapabilityStoreDictionaryRemoveRequest { id, key, dest_id },
17471                )
17472            }
17473
17474            #[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"]
17475            pub fn dictionary_remove_with<___R>(
17476                &self,
17477                request: ___R,
17478            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryRemove, ___T>
17479            where
17480                ___R: ::fidl_next::Encode<
17481                        <___T as ::fidl_next::Transport>::SendBuffer,
17482                        Encoded = crate::wire::CapabilityStoreDictionaryRemoveRequest<'static>,
17483                    >,
17484            {
17485                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17486                    343892214579320051,
17487                    <super::DictionaryRemove as ::fidl_next::Method>::FLEXIBILITY,
17488                    request,
17489                ))
17490            }
17491
17492            #[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"]
17493            pub fn dictionary_copy(
17494                &self,
17495
17496                id: impl ::fidl_next::Encode<
17497                    <___T as ::fidl_next::Transport>::SendBuffer,
17498                    Encoded = ::fidl_next::WireU64,
17499                >,
17500
17501                dest_id: impl ::fidl_next::Encode<
17502                    <___T as ::fidl_next::Transport>::SendBuffer,
17503                    Encoded = ::fidl_next::WireU64,
17504                >,
17505            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
17506            where
17507                <___T as ::fidl_next::Transport>::SendBuffer:
17508                    ::fidl_next::encoder::InternalHandleEncoder,
17509            {
17510                self.dictionary_copy_with(crate::generic::CapabilityStoreDictionaryCopyRequest {
17511                    id,
17512
17513                    dest_id,
17514                })
17515            }
17516
17517            #[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"]
17518            pub fn dictionary_copy_with<___R>(
17519                &self,
17520                request: ___R,
17521            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryCopy, ___T>
17522            where
17523                ___R: ::fidl_next::Encode<
17524                        <___T as ::fidl_next::Transport>::SendBuffer,
17525                        Encoded = crate::wire::CapabilityStoreDictionaryCopyRequest,
17526                    >,
17527            {
17528                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17529                    3977783339739362383,
17530                    <super::DictionaryCopy as ::fidl_next::Method>::FLEXIBILITY,
17531                    request,
17532                ))
17533            }
17534
17535            #[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"]
17536            pub fn dictionary_keys(
17537                &self,
17538
17539                id: impl ::fidl_next::Encode<
17540                    <___T as ::fidl_next::Transport>::SendBuffer,
17541                    Encoded = ::fidl_next::WireU64,
17542                >,
17543
17544                iterator: impl ::fidl_next::Encode<
17545                    <___T as ::fidl_next::Transport>::SendBuffer,
17546                    Encoded = ::fidl_next::ServerEnd<
17547                        crate::DictionaryKeysIterator,
17548                        ::fidl_next::fuchsia::WireChannel,
17549                    >,
17550                >,
17551            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
17552            where
17553                <___T as ::fidl_next::Transport>::SendBuffer:
17554                    ::fidl_next::encoder::InternalHandleEncoder,
17555                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17556            {
17557                self.dictionary_keys_with(crate::generic::CapabilityStoreDictionaryKeysRequest {
17558                    id,
17559
17560                    iterator,
17561                })
17562            }
17563
17564            #[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"]
17565            pub fn dictionary_keys_with<___R>(
17566                &self,
17567                request: ___R,
17568            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryKeys, ___T>
17569            where
17570                ___R: ::fidl_next::Encode<
17571                        <___T as ::fidl_next::Transport>::SendBuffer,
17572                        Encoded = crate::wire::CapabilityStoreDictionaryKeysRequest,
17573                    >,
17574            {
17575                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17576                    597577248872787102,
17577                    <super::DictionaryKeys as ::fidl_next::Method>::FLEXIBILITY,
17578                    request,
17579                ))
17580            }
17581
17582            #[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"]
17583            pub fn dictionary_enumerate(
17584                &self,
17585
17586                id: impl ::fidl_next::Encode<
17587                    <___T as ::fidl_next::Transport>::SendBuffer,
17588                    Encoded = ::fidl_next::WireU64,
17589                >,
17590
17591                iterator: impl ::fidl_next::Encode<
17592                    <___T as ::fidl_next::Transport>::SendBuffer,
17593                    Encoded = ::fidl_next::ServerEnd<
17594                        crate::DictionaryEnumerateIterator,
17595                        ::fidl_next::fuchsia::WireChannel,
17596                    >,
17597                >,
17598            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
17599            where
17600                <___T as ::fidl_next::Transport>::SendBuffer:
17601                    ::fidl_next::encoder::InternalHandleEncoder,
17602                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17603            {
17604                self.dictionary_enumerate_with(
17605                    crate::generic::CapabilityStoreDictionaryEnumerateRequest { id, iterator },
17606                )
17607            }
17608
17609            #[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"]
17610            pub fn dictionary_enumerate_with<___R>(
17611                &self,
17612                request: ___R,
17613            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryEnumerate, ___T>
17614            where
17615                ___R: ::fidl_next::Encode<
17616                        <___T as ::fidl_next::Transport>::SendBuffer,
17617                        Encoded = crate::wire::CapabilityStoreDictionaryEnumerateRequest,
17618                    >,
17619            {
17620                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17621                    964467096271472193,
17622                    <super::DictionaryEnumerate as ::fidl_next::Method>::FLEXIBILITY,
17623                    request,
17624                ))
17625            }
17626
17627            #[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"]
17628            pub fn dictionary_drain(
17629                &self,
17630
17631                id: impl ::fidl_next::Encode<
17632                    <___T as ::fidl_next::Transport>::SendBuffer,
17633                    Encoded = ::fidl_next::WireU64,
17634                >,
17635
17636                iterator: impl ::fidl_next::Encode<
17637                    <___T as ::fidl_next::Transport>::SendBuffer,
17638                    Encoded = ::fidl_next::ServerEnd<
17639                        crate::DictionaryDrainIterator,
17640                        ::fidl_next::fuchsia::WireOptionalChannel,
17641                    >,
17642                >,
17643            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
17644            where
17645                <___T as ::fidl_next::Transport>::SendBuffer:
17646                    ::fidl_next::encoder::InternalHandleEncoder,
17647                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
17648            {
17649                self.dictionary_drain_with(crate::generic::CapabilityStoreDictionaryDrainRequest {
17650                    id,
17651
17652                    iterator,
17653                })
17654            }
17655
17656            #[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"]
17657            pub fn dictionary_drain_with<___R>(
17658                &self,
17659                request: ___R,
17660            ) -> ::fidl_next::TwoWayFuture<'_, super::DictionaryDrain, ___T>
17661            where
17662                ___R: ::fidl_next::Encode<
17663                        <___T as ::fidl_next::Transport>::SendBuffer,
17664                        Encoded = crate::wire::CapabilityStoreDictionaryDrainRequest,
17665                    >,
17666            {
17667                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17668                    2928364469569621208,
17669                    <super::DictionaryDrain as ::fidl_next::Method>::FLEXIBILITY,
17670                    request,
17671                ))
17672            }
17673        }
17674
17675        /// The server for the `CapabilityStore` protocol.
17676        #[repr(transparent)]
17677        pub struct CapabilityStoreServer<___T: ::fidl_next::Transport> {
17678            server: ::fidl_next::protocol::Server<___T>,
17679        }
17680
17681        impl<___T> CapabilityStoreServer<___T> where ___T: ::fidl_next::Transport {}
17682    }
17683}
17684
17685/// A client handler for the CapabilityStore protocol.
17686///
17687/// See [`CapabilityStore`] for more details.
17688pub trait CapabilityStoreClientHandler<
17689    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17690    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17691>
17692{
17693    fn on_unknown_interaction(
17694        &mut self,
17695        ordinal: u64,
17696    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17697        ::core::future::ready(())
17698    }
17699}
17700
17701impl<___T> CapabilityStoreClientHandler<___T> for ::fidl_next::IgnoreEvents
17702where
17703    ___T: ::fidl_next::Transport,
17704{
17705    async fn on_unknown_interaction(&mut self, _: u64) {}
17706}
17707
17708impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for CapabilityStore
17709where
17710    ___H: CapabilityStoreClientHandler<___T> + ::core::marker::Send,
17711    ___T: ::fidl_next::Transport,
17712    <capability_store::Duplicate as ::fidl_next::Method>::Response:
17713        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17714    <capability_store::Drop as ::fidl_next::Method>::Response:
17715        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17716    <capability_store::Export as ::fidl_next::Method>::Response:
17717        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17718    <capability_store::Import as ::fidl_next::Method>::Response:
17719        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17720    <capability_store::ConnectorCreate as ::fidl_next::Method>::Response:
17721        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17722    <capability_store::ConnectorOpen as ::fidl_next::Method>::Response:
17723        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17724    <capability_store::DirConnectorCreate as ::fidl_next::Method>::Response:
17725        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17726    <capability_store::DirConnectorOpen as ::fidl_next::Method>::Response:
17727        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17728    <capability_store::DictionaryCreate as ::fidl_next::Method>::Response:
17729        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17730    <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Response:
17731        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17732    <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Response:
17733        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17734    <capability_store::DictionaryInsert as ::fidl_next::Method>::Response:
17735        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17736    <capability_store::DictionaryGet as ::fidl_next::Method>::Response:
17737        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17738    <capability_store::DictionaryRemove as ::fidl_next::Method>::Response:
17739        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17740    <capability_store::DictionaryCopy as ::fidl_next::Method>::Response:
17741        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17742    <capability_store::DictionaryKeys as ::fidl_next::Method>::Response:
17743        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17744    <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Response:
17745        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17746    <capability_store::DictionaryDrain as ::fidl_next::Method>::Response:
17747        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17748{
17749    async fn on_event(
17750        handler: &mut ___H,
17751        ordinal: u64,
17752        flexibility: ::fidl_next::protocol::Flexibility,
17753        buffer: ___T::RecvBuffer,
17754    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17755        match ordinal {
17756            ordinal => {
17757                handler.on_unknown_interaction(ordinal).await;
17758                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
17759                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17760                } else {
17761                    Ok(())
17762                }
17763            }
17764        }
17765    }
17766}
17767
17768/// A server handler for the CapabilityStore protocol.
17769///
17770/// See [`CapabilityStore`] for more details.
17771pub trait CapabilityStoreServerHandler<
17772    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17773    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17774>
17775{
17776    #[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"]
17777    fn duplicate(
17778        &mut self,
17779
17780        request: ::fidl_next::Request<capability_store::Duplicate, ___T>,
17781
17782        responder: ::fidl_next::Responder<capability_store::Duplicate, ___T>,
17783    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17784
17785    #[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"]
17786    fn drop(
17787        &mut self,
17788
17789        request: ::fidl_next::Request<capability_store::Drop, ___T>,
17790
17791        responder: ::fidl_next::Responder<capability_store::Drop, ___T>,
17792    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17793
17794    #[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"]
17795    fn export(
17796        &mut self,
17797
17798        request: ::fidl_next::Request<capability_store::Export, ___T>,
17799
17800        responder: ::fidl_next::Responder<capability_store::Export, ___T>,
17801    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17802
17803    #[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"]
17804    fn import(
17805        &mut self,
17806
17807        request: ::fidl_next::Request<capability_store::Import, ___T>,
17808
17809        responder: ::fidl_next::Responder<capability_store::Import, ___T>,
17810    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17811
17812    #[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"]
17813    fn connector_create(
17814        &mut self,
17815
17816        request: ::fidl_next::Request<capability_store::ConnectorCreate, ___T>,
17817
17818        responder: ::fidl_next::Responder<capability_store::ConnectorCreate, ___T>,
17819    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17820
17821    #[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"]
17822    fn connector_open(
17823        &mut self,
17824
17825        request: ::fidl_next::Request<capability_store::ConnectorOpen, ___T>,
17826
17827        responder: ::fidl_next::Responder<capability_store::ConnectorOpen, ___T>,
17828    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17829
17830    #[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"]
17831    fn dir_connector_create(
17832        &mut self,
17833
17834        request: ::fidl_next::Request<capability_store::DirConnectorCreate, ___T>,
17835
17836        responder: ::fidl_next::Responder<capability_store::DirConnectorCreate, ___T>,
17837    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17838
17839    #[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"]
17840    fn dir_connector_open(
17841        &mut self,
17842
17843        request: ::fidl_next::Request<capability_store::DirConnectorOpen, ___T>,
17844
17845        responder: ::fidl_next::Responder<capability_store::DirConnectorOpen, ___T>,
17846    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17847
17848    #[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"]
17849    fn dictionary_create(
17850        &mut self,
17851
17852        request: ::fidl_next::Request<capability_store::DictionaryCreate, ___T>,
17853
17854        responder: ::fidl_next::Responder<capability_store::DictionaryCreate, ___T>,
17855    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17856
17857    #[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"]
17858    fn dictionary_legacy_import(
17859        &mut self,
17860
17861        request: ::fidl_next::Request<capability_store::DictionaryLegacyImport, ___T>,
17862
17863        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyImport, ___T>,
17864    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17865
17866    #[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"]
17867    fn dictionary_legacy_export(
17868        &mut self,
17869
17870        request: ::fidl_next::Request<capability_store::DictionaryLegacyExport, ___T>,
17871
17872        responder: ::fidl_next::Responder<capability_store::DictionaryLegacyExport, ___T>,
17873    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17874
17875    #[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"]
17876    fn dictionary_insert(
17877        &mut self,
17878
17879        request: ::fidl_next::Request<capability_store::DictionaryInsert, ___T>,
17880
17881        responder: ::fidl_next::Responder<capability_store::DictionaryInsert, ___T>,
17882    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17883
17884    #[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"]
17885    fn dictionary_get(
17886        &mut self,
17887
17888        request: ::fidl_next::Request<capability_store::DictionaryGet, ___T>,
17889
17890        responder: ::fidl_next::Responder<capability_store::DictionaryGet, ___T>,
17891    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17892
17893    #[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"]
17894    fn dictionary_remove(
17895        &mut self,
17896
17897        request: ::fidl_next::Request<capability_store::DictionaryRemove, ___T>,
17898
17899        responder: ::fidl_next::Responder<capability_store::DictionaryRemove, ___T>,
17900    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17901
17902    #[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"]
17903    fn dictionary_copy(
17904        &mut self,
17905
17906        request: ::fidl_next::Request<capability_store::DictionaryCopy, ___T>,
17907
17908        responder: ::fidl_next::Responder<capability_store::DictionaryCopy, ___T>,
17909    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17910
17911    #[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"]
17912    fn dictionary_keys(
17913        &mut self,
17914
17915        request: ::fidl_next::Request<capability_store::DictionaryKeys, ___T>,
17916
17917        responder: ::fidl_next::Responder<capability_store::DictionaryKeys, ___T>,
17918    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17919
17920    #[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"]
17921    fn dictionary_enumerate(
17922        &mut self,
17923
17924        request: ::fidl_next::Request<capability_store::DictionaryEnumerate, ___T>,
17925
17926        responder: ::fidl_next::Responder<capability_store::DictionaryEnumerate, ___T>,
17927    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17928
17929    #[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"]
17930    fn dictionary_drain(
17931        &mut self,
17932
17933        request: ::fidl_next::Request<capability_store::DictionaryDrain, ___T>,
17934
17935        responder: ::fidl_next::Responder<capability_store::DictionaryDrain, ___T>,
17936    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17937
17938    fn on_unknown_interaction(
17939        &mut self,
17940        ordinal: u64,
17941    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
17942        ::core::future::ready(())
17943    }
17944}
17945
17946impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for CapabilityStore
17947where
17948    ___H: CapabilityStoreServerHandler<___T> + ::core::marker::Send,
17949    ___T: ::fidl_next::Transport,
17950    <capability_store::Duplicate as ::fidl_next::Method>::Request:
17951        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17952    <capability_store::Drop as ::fidl_next::Method>::Request:
17953        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17954    <capability_store::Export as ::fidl_next::Method>::Request:
17955        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17956    <capability_store::Import as ::fidl_next::Method>::Request:
17957        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17958    <capability_store::ConnectorCreate as ::fidl_next::Method>::Request:
17959        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17960    <capability_store::ConnectorOpen as ::fidl_next::Method>::Request:
17961        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17962    <capability_store::DirConnectorCreate as ::fidl_next::Method>::Request:
17963        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17964    <capability_store::DirConnectorOpen as ::fidl_next::Method>::Request:
17965        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17966    <capability_store::DictionaryCreate as ::fidl_next::Method>::Request:
17967        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17968    <capability_store::DictionaryLegacyImport as ::fidl_next::Method>::Request:
17969        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17970    <capability_store::DictionaryLegacyExport as ::fidl_next::Method>::Request:
17971        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17972    <capability_store::DictionaryInsert as ::fidl_next::Method>::Request:
17973        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17974    <capability_store::DictionaryGet as ::fidl_next::Method>::Request:
17975        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17976    <capability_store::DictionaryRemove as ::fidl_next::Method>::Request:
17977        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17978    <capability_store::DictionaryCopy as ::fidl_next::Method>::Request:
17979        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17980    <capability_store::DictionaryKeys as ::fidl_next::Method>::Request:
17981        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17982    <capability_store::DictionaryEnumerate as ::fidl_next::Method>::Request:
17983        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17984    <capability_store::DictionaryDrain as ::fidl_next::Method>::Request:
17985        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
17986{
17987    async fn on_one_way(
17988        handler: &mut ___H,
17989        ordinal: u64,
17990        flexibility: ::fidl_next::protocol::Flexibility,
17991        buffer: ___T::RecvBuffer,
17992    ) -> ::core::result::Result<
17993        (),
17994        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17995    > {
17996        match ordinal {
17997            ordinal => {
17998                handler.on_unknown_interaction(ordinal).await;
17999                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18000                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18001                } else {
18002                    Ok(())
18003                }
18004            }
18005        }
18006    }
18007
18008    async fn on_two_way(
18009        handler: &mut ___H,
18010        ordinal: u64,
18011        flexibility: ::fidl_next::protocol::Flexibility,
18012        buffer: ___T::RecvBuffer,
18013        responder: ::fidl_next::protocol::Responder<___T>,
18014    ) -> ::core::result::Result<
18015        (),
18016        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18017    > {
18018        match ordinal {
18019            6727592627741008260 => {
18020                let responder = ::fidl_next::Responder::from_untyped(responder);
18021
18022                match ::fidl_next::DecoderExt::decode(buffer) {
18023                    Ok(decoded) => {
18024                        handler.duplicate(decoded, responder).await;
18025                        Ok(())
18026                    }
18027                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18028                        ordinal: 6727592627741008260,
18029                        error,
18030                    }),
18031                }
18032            }
18033
18034            753328233834620249 => {
18035                let responder = ::fidl_next::Responder::from_untyped(responder);
18036
18037                match ::fidl_next::DecoderExt::decode(buffer) {
18038                    Ok(decoded) => {
18039                        handler.drop(decoded, responder).await;
18040                        Ok(())
18041                    }
18042                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18043                        ordinal: 753328233834620249,
18044                        error,
18045                    }),
18046                }
18047            }
18048
18049            226159162093533951 => {
18050                let responder = ::fidl_next::Responder::from_untyped(responder);
18051
18052                match ::fidl_next::DecoderExt::decode(buffer) {
18053                    Ok(decoded) => {
18054                        handler.export(decoded, responder).await;
18055                        Ok(())
18056                    }
18057                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18058                        ordinal: 226159162093533951,
18059                        error,
18060                    }),
18061                }
18062            }
18063
18064            2276030276116435867 => {
18065                let responder = ::fidl_next::Responder::from_untyped(responder);
18066
18067                match ::fidl_next::DecoderExt::decode(buffer) {
18068                    Ok(decoded) => {
18069                        handler.import(decoded, responder).await;
18070                        Ok(())
18071                    }
18072                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18073                        ordinal: 2276030276116435867,
18074                        error,
18075                    }),
18076                }
18077            }
18078
18079            2979461408102095909 => {
18080                let responder = ::fidl_next::Responder::from_untyped(responder);
18081
18082                match ::fidl_next::DecoderExt::decode(buffer) {
18083                    Ok(decoded) => {
18084                        handler.connector_create(decoded, responder).await;
18085                        Ok(())
18086                    }
18087                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18088                        ordinal: 2979461408102095909,
18089                        error,
18090                    }),
18091                }
18092            }
18093
18094            6016362336453278623 => {
18095                let responder = ::fidl_next::Responder::from_untyped(responder);
18096
18097                match ::fidl_next::DecoderExt::decode(buffer) {
18098                    Ok(decoded) => {
18099                        handler.connector_open(decoded, responder).await;
18100                        Ok(())
18101                    }
18102                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18103                        ordinal: 6016362336453278623,
18104                        error,
18105                    }),
18106                }
18107            }
18108
18109            1756747594275428795 => {
18110                let responder = ::fidl_next::Responder::from_untyped(responder);
18111
18112                match ::fidl_next::DecoderExt::decode(buffer) {
18113                    Ok(decoded) => {
18114                        handler.dir_connector_create(decoded, responder).await;
18115                        Ok(())
18116                    }
18117                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18118                        ordinal: 1756747594275428795,
18119                        error,
18120                    }),
18121                }
18122            }
18123
18124            6219704004220369153 => {
18125                let responder = ::fidl_next::Responder::from_untyped(responder);
18126
18127                match ::fidl_next::DecoderExt::decode(buffer) {
18128                    Ok(decoded) => {
18129                        handler.dir_connector_open(decoded, responder).await;
18130                        Ok(())
18131                    }
18132                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18133                        ordinal: 6219704004220369153,
18134                        error,
18135                    }),
18136                }
18137            }
18138
18139            7608770958894948499 => {
18140                let responder = ::fidl_next::Responder::from_untyped(responder);
18141
18142                match ::fidl_next::DecoderExt::decode(buffer) {
18143                    Ok(decoded) => {
18144                        handler.dictionary_create(decoded, responder).await;
18145                        Ok(())
18146                    }
18147                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18148                        ordinal: 7608770958894948499,
18149                        error,
18150                    }),
18151                }
18152            }
18153
18154            8285893703432012383 => {
18155                let responder = ::fidl_next::Responder::from_untyped(responder);
18156
18157                match ::fidl_next::DecoderExt::decode(buffer) {
18158                    Ok(decoded) => {
18159                        handler.dictionary_legacy_import(decoded, responder).await;
18160                        Ok(())
18161                    }
18162                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18163                        ordinal: 8285893703432012383,
18164                        error,
18165                    }),
18166                }
18167            }
18168
18169            4647175832683306445 => {
18170                let responder = ::fidl_next::Responder::from_untyped(responder);
18171
18172                match ::fidl_next::DecoderExt::decode(buffer) {
18173                    Ok(decoded) => {
18174                        handler.dictionary_legacy_export(decoded, responder).await;
18175                        Ok(())
18176                    }
18177                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18178                        ordinal: 4647175832683306445,
18179                        error,
18180                    }),
18181                }
18182            }
18183
18184            8575443262986538023 => {
18185                let responder = ::fidl_next::Responder::from_untyped(responder);
18186
18187                match ::fidl_next::DecoderExt::decode(buffer) {
18188                    Ok(decoded) => {
18189                        handler.dictionary_insert(decoded, responder).await;
18190                        Ok(())
18191                    }
18192                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18193                        ordinal: 8575443262986538023,
18194                        error,
18195                    }),
18196                }
18197            }
18198
18199            5592951026866236882 => {
18200                let responder = ::fidl_next::Responder::from_untyped(responder);
18201
18202                match ::fidl_next::DecoderExt::decode(buffer) {
18203                    Ok(decoded) => {
18204                        handler.dictionary_get(decoded, responder).await;
18205                        Ok(())
18206                    }
18207                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18208                        ordinal: 5592951026866236882,
18209                        error,
18210                    }),
18211                }
18212            }
18213
18214            343892214579320051 => {
18215                let responder = ::fidl_next::Responder::from_untyped(responder);
18216
18217                match ::fidl_next::DecoderExt::decode(buffer) {
18218                    Ok(decoded) => {
18219                        handler.dictionary_remove(decoded, responder).await;
18220                        Ok(())
18221                    }
18222                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18223                        ordinal: 343892214579320051,
18224                        error,
18225                    }),
18226                }
18227            }
18228
18229            3977783339739362383 => {
18230                let responder = ::fidl_next::Responder::from_untyped(responder);
18231
18232                match ::fidl_next::DecoderExt::decode(buffer) {
18233                    Ok(decoded) => {
18234                        handler.dictionary_copy(decoded, responder).await;
18235                        Ok(())
18236                    }
18237                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18238                        ordinal: 3977783339739362383,
18239                        error,
18240                    }),
18241                }
18242            }
18243
18244            597577248872787102 => {
18245                let responder = ::fidl_next::Responder::from_untyped(responder);
18246
18247                match ::fidl_next::DecoderExt::decode(buffer) {
18248                    Ok(decoded) => {
18249                        handler.dictionary_keys(decoded, responder).await;
18250                        Ok(())
18251                    }
18252                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18253                        ordinal: 597577248872787102,
18254                        error,
18255                    }),
18256                }
18257            }
18258
18259            964467096271472193 => {
18260                let responder = ::fidl_next::Responder::from_untyped(responder);
18261
18262                match ::fidl_next::DecoderExt::decode(buffer) {
18263                    Ok(decoded) => {
18264                        handler.dictionary_enumerate(decoded, responder).await;
18265                        Ok(())
18266                    }
18267                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18268                        ordinal: 964467096271472193,
18269                        error,
18270                    }),
18271                }
18272            }
18273
18274            2928364469569621208 => {
18275                let responder = ::fidl_next::Responder::from_untyped(responder);
18276
18277                match ::fidl_next::DecoderExt::decode(buffer) {
18278                    Ok(decoded) => {
18279                        handler.dictionary_drain(decoded, responder).await;
18280                        Ok(())
18281                    }
18282                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18283                        ordinal: 2928364469569621208,
18284                        error,
18285                    }),
18286                }
18287            }
18288
18289            ordinal => {
18290                handler.on_unknown_interaction(ordinal).await;
18291                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18292                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18293                } else {
18294                    responder
18295                        .respond(
18296                            ordinal,
18297                            flexibility,
18298                            ::fidl_next::Flexible::<()>::FrameworkErr(
18299                                ::fidl_next::FrameworkError::UnknownMethod,
18300                            ),
18301                        )
18302                        .expect("encoding a framework error should never fail")
18303                        .await?;
18304                    Ok(())
18305                }
18306            }
18307        }
18308    }
18309}
18310
18311/// The type corresponding to the ConnectorRouter protocol.
18312#[derive(PartialEq, Debug)]
18313pub struct ConnectorRouter;
18314
18315impl ::fidl_next::Discoverable for ConnectorRouter {
18316    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.ConnectorRouter";
18317}
18318
18319#[cfg(target_os = "fuchsia")]
18320impl ::fidl_next::HasTransport for ConnectorRouter {
18321    type Transport = ::fidl_next::fuchsia::zx::Channel;
18322}
18323
18324pub mod connector_router {
18325    pub mod prelude {
18326        pub use crate::{
18327            ConnectorRouter, ConnectorRouterClientHandler, ConnectorRouterServerHandler,
18328            connector_router,
18329        };
18330
18331        pub use crate::natural::ConnectorRouterRouteResponse;
18332
18333        pub use crate::natural::RouteRequest;
18334
18335        pub use crate::natural::RouterError;
18336    }
18337
18338    pub struct Route;
18339
18340    impl ::fidl_next::Method for Route {
18341        const ORDINAL: u64 = 8420527046218942310;
18342        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18343            ::fidl_next::protocol::Flexibility::Flexible;
18344
18345        type Protocol = crate::ConnectorRouter;
18346
18347        type Request = crate::wire::RouteRequest<'static>;
18348
18349        type Response = ::fidl_next::WireFlexibleResult<
18350            'static,
18351            crate::wire::ConnectorRouterRouteResponse,
18352            crate::wire::RouterError,
18353        >;
18354    }
18355
18356    impl<___R> ::fidl_next::Respond<___R> for Route {
18357        type Output = ::fidl_next::FlexibleResult<
18358            ___R,
18359            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
18360        >;
18361
18362        fn respond(response: ___R) -> Self::Output {
18363            ::fidl_next::FlexibleResult::Ok(response)
18364        }
18365    }
18366
18367    impl<___R> ::fidl_next::RespondErr<___R> for Route {
18368        type Output = ::fidl_next::FlexibleResult<
18369            ::fidl_next::util::EncodableNever<crate::wire::ConnectorRouterRouteResponse>,
18370            ___R,
18371        >;
18372
18373        fn respond_err(response: ___R) -> Self::Output {
18374            ::fidl_next::FlexibleResult::Err(response)
18375        }
18376    }
18377
18378    mod ___detail {
18379        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ConnectorRouter
18380        where
18381            ___T: ::fidl_next::Transport,
18382        {
18383            type Client = ConnectorRouterClient<___T>;
18384            type Server = ConnectorRouterServer<___T>;
18385        }
18386
18387        /// The client for the `ConnectorRouter` protocol.
18388        #[repr(transparent)]
18389        pub struct ConnectorRouterClient<___T: ::fidl_next::Transport> {
18390            #[allow(dead_code)]
18391            client: ::fidl_next::protocol::Client<___T>,
18392        }
18393
18394        impl<___T> ConnectorRouterClient<___T>
18395        where
18396            ___T: ::fidl_next::Transport,
18397        {
18398            pub fn route_with<___R>(
18399                &self,
18400                request: ___R,
18401            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
18402            where
18403                ___R: ::fidl_next::Encode<
18404                        <___T as ::fidl_next::Transport>::SendBuffer,
18405                        Encoded = crate::wire::RouteRequest<'static>,
18406                    >,
18407            {
18408                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18409                    8420527046218942310,
18410                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
18411                    request,
18412                ))
18413            }
18414        }
18415
18416        /// The server for the `ConnectorRouter` protocol.
18417        #[repr(transparent)]
18418        pub struct ConnectorRouterServer<___T: ::fidl_next::Transport> {
18419            server: ::fidl_next::protocol::Server<___T>,
18420        }
18421
18422        impl<___T> ConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
18423    }
18424}
18425
18426/// A client handler for the ConnectorRouter protocol.
18427///
18428/// See [`ConnectorRouter`] for more details.
18429pub trait ConnectorRouterClientHandler<
18430    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18431    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18432>
18433{
18434    fn on_unknown_interaction(
18435        &mut self,
18436        ordinal: u64,
18437    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18438        ::core::future::ready(())
18439    }
18440}
18441
18442impl<___T> ConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
18443where
18444    ___T: ::fidl_next::Transport,
18445{
18446    async fn on_unknown_interaction(&mut self, _: u64) {}
18447}
18448
18449impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ConnectorRouter
18450where
18451    ___H: ConnectorRouterClientHandler<___T> + ::core::marker::Send,
18452    ___T: ::fidl_next::Transport,
18453    <connector_router::Route as ::fidl_next::Method>::Response:
18454        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18455{
18456    async fn on_event(
18457        handler: &mut ___H,
18458        ordinal: u64,
18459        flexibility: ::fidl_next::protocol::Flexibility,
18460        buffer: ___T::RecvBuffer,
18461    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18462        match ordinal {
18463            ordinal => {
18464                handler.on_unknown_interaction(ordinal).await;
18465                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18466                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18467                } else {
18468                    Ok(())
18469                }
18470            }
18471        }
18472    }
18473}
18474
18475/// A server handler for the ConnectorRouter protocol.
18476///
18477/// See [`ConnectorRouter`] for more details.
18478pub trait ConnectorRouterServerHandler<
18479    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18480    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18481>
18482{
18483    fn route(
18484        &mut self,
18485
18486        request: ::fidl_next::Request<connector_router::Route, ___T>,
18487
18488        responder: ::fidl_next::Responder<connector_router::Route, ___T>,
18489    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18490
18491    fn on_unknown_interaction(
18492        &mut self,
18493        ordinal: u64,
18494    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18495        ::core::future::ready(())
18496    }
18497}
18498
18499impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ConnectorRouter
18500where
18501    ___H: ConnectorRouterServerHandler<___T> + ::core::marker::Send,
18502    ___T: ::fidl_next::Transport,
18503    <connector_router::Route as ::fidl_next::Method>::Request:
18504        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18505{
18506    async fn on_one_way(
18507        handler: &mut ___H,
18508        ordinal: u64,
18509        flexibility: ::fidl_next::protocol::Flexibility,
18510        buffer: ___T::RecvBuffer,
18511    ) -> ::core::result::Result<
18512        (),
18513        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18514    > {
18515        match ordinal {
18516            ordinal => {
18517                handler.on_unknown_interaction(ordinal).await;
18518                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18519                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18520                } else {
18521                    Ok(())
18522                }
18523            }
18524        }
18525    }
18526
18527    async fn on_two_way(
18528        handler: &mut ___H,
18529        ordinal: u64,
18530        flexibility: ::fidl_next::protocol::Flexibility,
18531        buffer: ___T::RecvBuffer,
18532        responder: ::fidl_next::protocol::Responder<___T>,
18533    ) -> ::core::result::Result<
18534        (),
18535        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18536    > {
18537        match ordinal {
18538            8420527046218942310 => {
18539                let responder = ::fidl_next::Responder::from_untyped(responder);
18540
18541                match ::fidl_next::DecoderExt::decode(buffer) {
18542                    Ok(decoded) => {
18543                        handler.route(decoded, responder).await;
18544                        Ok(())
18545                    }
18546                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18547                        ordinal: 8420527046218942310,
18548                        error,
18549                    }),
18550                }
18551            }
18552
18553            ordinal => {
18554                handler.on_unknown_interaction(ordinal).await;
18555                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18556                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18557                } else {
18558                    responder
18559                        .respond(
18560                            ordinal,
18561                            flexibility,
18562                            ::fidl_next::Flexible::<()>::FrameworkErr(
18563                                ::fidl_next::FrameworkError::UnknownMethod,
18564                            ),
18565                        )
18566                        .expect("encoding a framework error should never fail")
18567                        .await?;
18568                    Ok(())
18569                }
18570            }
18571        }
18572    }
18573}
18574
18575/// The type corresponding to the DataRouter protocol.
18576#[derive(PartialEq, Debug)]
18577pub struct DataRouter;
18578
18579impl ::fidl_next::Discoverable for DataRouter {
18580    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DataRouter";
18581}
18582
18583#[cfg(target_os = "fuchsia")]
18584impl ::fidl_next::HasTransport for DataRouter {
18585    type Transport = ::fidl_next::fuchsia::zx::Channel;
18586}
18587
18588pub mod data_router {
18589    pub mod prelude {
18590        pub use crate::{
18591            DataRouter, DataRouterClientHandler, DataRouterServerHandler, data_router,
18592        };
18593
18594        pub use crate::natural::DataRouterRouteResponse;
18595
18596        pub use crate::natural::RouteRequest;
18597
18598        pub use crate::natural::RouterError;
18599    }
18600
18601    pub struct Route;
18602
18603    impl ::fidl_next::Method for Route {
18604        const ORDINAL: u64 = 3352890635970754564;
18605        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18606            ::fidl_next::protocol::Flexibility::Flexible;
18607
18608        type Protocol = crate::DataRouter;
18609
18610        type Request = crate::wire::RouteRequest<'static>;
18611
18612        type Response = ::fidl_next::WireFlexibleResult<
18613            'static,
18614            crate::wire::DataRouterRouteResponse<'static>,
18615            crate::wire::RouterError,
18616        >;
18617    }
18618
18619    impl<___R> ::fidl_next::Respond<___R> for Route {
18620        type Output = ::fidl_next::FlexibleResult<
18621            ___R,
18622            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
18623        >;
18624
18625        fn respond(response: ___R) -> Self::Output {
18626            ::fidl_next::FlexibleResult::Ok(response)
18627        }
18628    }
18629
18630    impl<___R> ::fidl_next::RespondErr<___R> for Route {
18631        type Output = ::fidl_next::FlexibleResult<
18632            ::fidl_next::util::EncodableNever<crate::wire::DataRouterRouteResponse<'static>>,
18633            ___R,
18634        >;
18635
18636        fn respond_err(response: ___R) -> Self::Output {
18637            ::fidl_next::FlexibleResult::Err(response)
18638        }
18639    }
18640
18641    mod ___detail {
18642        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DataRouter
18643        where
18644            ___T: ::fidl_next::Transport,
18645        {
18646            type Client = DataRouterClient<___T>;
18647            type Server = DataRouterServer<___T>;
18648        }
18649
18650        /// The client for the `DataRouter` protocol.
18651        #[repr(transparent)]
18652        pub struct DataRouterClient<___T: ::fidl_next::Transport> {
18653            #[allow(dead_code)]
18654            client: ::fidl_next::protocol::Client<___T>,
18655        }
18656
18657        impl<___T> DataRouterClient<___T>
18658        where
18659            ___T: ::fidl_next::Transport,
18660        {
18661            pub fn route_with<___R>(
18662                &self,
18663                request: ___R,
18664            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
18665            where
18666                ___R: ::fidl_next::Encode<
18667                        <___T as ::fidl_next::Transport>::SendBuffer,
18668                        Encoded = crate::wire::RouteRequest<'static>,
18669                    >,
18670            {
18671                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18672                    3352890635970754564,
18673                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
18674                    request,
18675                ))
18676            }
18677        }
18678
18679        /// The server for the `DataRouter` protocol.
18680        #[repr(transparent)]
18681        pub struct DataRouterServer<___T: ::fidl_next::Transport> {
18682            server: ::fidl_next::protocol::Server<___T>,
18683        }
18684
18685        impl<___T> DataRouterServer<___T> where ___T: ::fidl_next::Transport {}
18686    }
18687}
18688
18689/// A client handler for the DataRouter protocol.
18690///
18691/// See [`DataRouter`] for more details.
18692pub trait DataRouterClientHandler<
18693    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18694    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18695>
18696{
18697    fn on_unknown_interaction(
18698        &mut self,
18699        ordinal: u64,
18700    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18701        ::core::future::ready(())
18702    }
18703}
18704
18705impl<___T> DataRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
18706where
18707    ___T: ::fidl_next::Transport,
18708{
18709    async fn on_unknown_interaction(&mut self, _: u64) {}
18710}
18711
18712impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DataRouter
18713where
18714    ___H: DataRouterClientHandler<___T> + ::core::marker::Send,
18715    ___T: ::fidl_next::Transport,
18716    <data_router::Route as ::fidl_next::Method>::Response:
18717        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18718{
18719    async fn on_event(
18720        handler: &mut ___H,
18721        ordinal: u64,
18722        flexibility: ::fidl_next::protocol::Flexibility,
18723        buffer: ___T::RecvBuffer,
18724    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18725        match ordinal {
18726            ordinal => {
18727                handler.on_unknown_interaction(ordinal).await;
18728                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18729                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18730                } else {
18731                    Ok(())
18732                }
18733            }
18734        }
18735    }
18736}
18737
18738/// A server handler for the DataRouter protocol.
18739///
18740/// See [`DataRouter`] for more details.
18741pub trait DataRouterServerHandler<
18742    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18743    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18744>
18745{
18746    fn route(
18747        &mut self,
18748
18749        request: ::fidl_next::Request<data_router::Route, ___T>,
18750
18751        responder: ::fidl_next::Responder<data_router::Route, ___T>,
18752    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18753
18754    fn on_unknown_interaction(
18755        &mut self,
18756        ordinal: u64,
18757    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18758        ::core::future::ready(())
18759    }
18760}
18761
18762impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DataRouter
18763where
18764    ___H: DataRouterServerHandler<___T> + ::core::marker::Send,
18765    ___T: ::fidl_next::Transport,
18766    <data_router::Route as ::fidl_next::Method>::Request:
18767        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
18768{
18769    async fn on_one_way(
18770        handler: &mut ___H,
18771        ordinal: u64,
18772        flexibility: ::fidl_next::protocol::Flexibility,
18773        buffer: ___T::RecvBuffer,
18774    ) -> ::core::result::Result<
18775        (),
18776        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18777    > {
18778        match ordinal {
18779            ordinal => {
18780                handler.on_unknown_interaction(ordinal).await;
18781                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18782                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18783                } else {
18784                    Ok(())
18785                }
18786            }
18787        }
18788    }
18789
18790    async fn on_two_way(
18791        handler: &mut ___H,
18792        ordinal: u64,
18793        flexibility: ::fidl_next::protocol::Flexibility,
18794        buffer: ___T::RecvBuffer,
18795        responder: ::fidl_next::protocol::Responder<___T>,
18796    ) -> ::core::result::Result<
18797        (),
18798        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18799    > {
18800        match ordinal {
18801            3352890635970754564 => {
18802                let responder = ::fidl_next::Responder::from_untyped(responder);
18803
18804                match ::fidl_next::DecoderExt::decode(buffer) {
18805                    Ok(decoded) => {
18806                        handler.route(decoded, responder).await;
18807                        Ok(())
18808                    }
18809                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18810                        ordinal: 3352890635970754564,
18811                        error,
18812                    }),
18813                }
18814            }
18815
18816            ordinal => {
18817                handler.on_unknown_interaction(ordinal).await;
18818                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18819                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18820                } else {
18821                    responder
18822                        .respond(
18823                            ordinal,
18824                            flexibility,
18825                            ::fidl_next::Flexible::<()>::FrameworkErr(
18826                                ::fidl_next::FrameworkError::UnknownMethod,
18827                            ),
18828                        )
18829                        .expect("encoding a framework error should never fail")
18830                        .await?;
18831                    Ok(())
18832                }
18833            }
18834        }
18835    }
18836}
18837
18838/// The type corresponding to the Dictionary protocol.
18839#[derive(PartialEq, Debug)]
18840pub struct Dictionary;
18841
18842impl ::fidl_next::Discoverable for Dictionary {
18843    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Dictionary";
18844}
18845
18846#[cfg(target_os = "fuchsia")]
18847impl ::fidl_next::HasTransport for Dictionary {
18848    type Transport = ::fidl_next::fuchsia::zx::Channel;
18849}
18850
18851pub mod dictionary {
18852    pub mod prelude {
18853        pub use crate::{Dictionary, DictionaryClientHandler, DictionaryServerHandler, dictionary};
18854    }
18855
18856    mod ___detail {
18857        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Dictionary
18858        where
18859            ___T: ::fidl_next::Transport,
18860        {
18861            type Client = DictionaryClient<___T>;
18862            type Server = DictionaryServer<___T>;
18863        }
18864
18865        /// The client for the `Dictionary` protocol.
18866        #[repr(transparent)]
18867        pub struct DictionaryClient<___T: ::fidl_next::Transport> {
18868            #[allow(dead_code)]
18869            client: ::fidl_next::protocol::Client<___T>,
18870        }
18871
18872        impl<___T> DictionaryClient<___T> where ___T: ::fidl_next::Transport {}
18873
18874        /// The server for the `Dictionary` protocol.
18875        #[repr(transparent)]
18876        pub struct DictionaryServer<___T: ::fidl_next::Transport> {
18877            server: ::fidl_next::protocol::Server<___T>,
18878        }
18879
18880        impl<___T> DictionaryServer<___T> where ___T: ::fidl_next::Transport {}
18881    }
18882}
18883
18884/// A client handler for the Dictionary protocol.
18885///
18886/// See [`Dictionary`] for more details.
18887pub trait DictionaryClientHandler<
18888    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18889    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18890>
18891{
18892    fn on_unknown_interaction(
18893        &mut self,
18894        ordinal: u64,
18895    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18896        ::core::future::ready(())
18897    }
18898}
18899
18900impl<___T> DictionaryClientHandler<___T> for ::fidl_next::IgnoreEvents
18901where
18902    ___T: ::fidl_next::Transport,
18903{
18904    async fn on_unknown_interaction(&mut self, _: u64) {}
18905}
18906
18907impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Dictionary
18908where
18909    ___H: DictionaryClientHandler<___T> + ::core::marker::Send,
18910    ___T: ::fidl_next::Transport,
18911{
18912    async fn on_event(
18913        handler: &mut ___H,
18914        ordinal: u64,
18915        flexibility: ::fidl_next::protocol::Flexibility,
18916        buffer: ___T::RecvBuffer,
18917    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18918        match ordinal {
18919            ordinal => {
18920                handler.on_unknown_interaction(ordinal).await;
18921                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18922                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18923                } else {
18924                    Ok(())
18925                }
18926            }
18927        }
18928    }
18929}
18930
18931/// A server handler for the Dictionary protocol.
18932///
18933/// See [`Dictionary`] for more details.
18934pub trait DictionaryServerHandler<
18935    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18936    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18937>
18938{
18939    fn on_unknown_interaction(
18940        &mut self,
18941        ordinal: u64,
18942    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
18943        ::core::future::ready(())
18944    }
18945}
18946
18947impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Dictionary
18948where
18949    ___H: DictionaryServerHandler<___T> + ::core::marker::Send,
18950    ___T: ::fidl_next::Transport,
18951{
18952    async fn on_one_way(
18953        handler: &mut ___H,
18954        ordinal: u64,
18955        flexibility: ::fidl_next::protocol::Flexibility,
18956        buffer: ___T::RecvBuffer,
18957    ) -> ::core::result::Result<
18958        (),
18959        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18960    > {
18961        match ordinal {
18962            ordinal => {
18963                handler.on_unknown_interaction(ordinal).await;
18964                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18965                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18966                } else {
18967                    Ok(())
18968                }
18969            }
18970        }
18971    }
18972
18973    async fn on_two_way(
18974        handler: &mut ___H,
18975        ordinal: u64,
18976        flexibility: ::fidl_next::protocol::Flexibility,
18977        buffer: ___T::RecvBuffer,
18978        responder: ::fidl_next::protocol::Responder<___T>,
18979    ) -> ::core::result::Result<
18980        (),
18981        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18982    > {
18983        match ordinal {
18984            ordinal => {
18985                handler.on_unknown_interaction(ordinal).await;
18986                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
18987                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
18988                } else {
18989                    responder
18990                        .respond(
18991                            ordinal,
18992                            flexibility,
18993                            ::fidl_next::Flexible::<()>::FrameworkErr(
18994                                ::fidl_next::FrameworkError::UnknownMethod,
18995                            ),
18996                        )
18997                        .expect("encoding a framework error should never fail")
18998                        .await?;
18999                    Ok(())
19000                }
19001            }
19002        }
19003    }
19004}
19005
19006#[doc = " Maximum number of items returned by dictionary iterator.\n"]
19007pub const MAX_DICTIONARY_ITERATOR_CHUNK: u32 = 128 as u32;
19008
19009/// The type corresponding to the DictionaryDrainIterator protocol.
19010#[derive(PartialEq, Debug)]
19011pub struct DictionaryDrainIterator;
19012
19013#[cfg(target_os = "fuchsia")]
19014impl ::fidl_next::HasTransport for DictionaryDrainIterator {
19015    type Transport = ::fidl_next::fuchsia::zx::Channel;
19016}
19017
19018pub mod dictionary_drain_iterator {
19019    pub mod prelude {
19020        pub use crate::{
19021            DictionaryDrainIterator, DictionaryDrainIteratorClientHandler,
19022            DictionaryDrainIteratorServerHandler, dictionary_drain_iterator,
19023        };
19024
19025        pub use crate::natural::CapabilityStoreError;
19026
19027        pub use crate::natural::DictionaryDrainIteratorGetNextRequest;
19028
19029        pub use crate::natural::DictionaryDrainIteratorGetNextResponse;
19030    }
19031
19032    pub struct GetNext;
19033
19034    impl ::fidl_next::Method for GetNext {
19035        const ORDINAL: u64 = 5728722530628427873;
19036        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19037            ::fidl_next::protocol::Flexibility::Flexible;
19038
19039        type Protocol = crate::DictionaryDrainIterator;
19040
19041        type Request = crate::wire::DictionaryDrainIteratorGetNextRequest;
19042
19043        type Response = ::fidl_next::WireFlexibleResult<
19044            'static,
19045            crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
19046            crate::wire::CapabilityStoreError,
19047        >;
19048    }
19049
19050    impl<___R> ::fidl_next::Respond<___R> for GetNext {
19051        type Output = ::fidl_next::FlexibleResult<
19052            ___R,
19053            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
19054        >;
19055
19056        fn respond(response: ___R) -> Self::Output {
19057            ::fidl_next::FlexibleResult::Ok(response)
19058        }
19059    }
19060
19061    impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
19062        type Output = ::fidl_next::FlexibleResult<
19063            ::fidl_next::util::EncodableNever<
19064                crate::wire::DictionaryDrainIteratorGetNextResponse<'static>,
19065            >,
19066            ___R,
19067        >;
19068
19069        fn respond_err(response: ___R) -> Self::Output {
19070            ::fidl_next::FlexibleResult::Err(response)
19071        }
19072    }
19073
19074    mod ___detail {
19075        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryDrainIterator
19076        where
19077            ___T: ::fidl_next::Transport,
19078        {
19079            type Client = DictionaryDrainIteratorClient<___T>;
19080            type Server = DictionaryDrainIteratorServer<___T>;
19081        }
19082
19083        /// The client for the `DictionaryDrainIterator` protocol.
19084        #[repr(transparent)]
19085        pub struct DictionaryDrainIteratorClient<___T: ::fidl_next::Transport> {
19086            #[allow(dead_code)]
19087            client: ::fidl_next::protocol::Client<___T>,
19088        }
19089
19090        impl<___T> DictionaryDrainIteratorClient<___T>
19091        where
19092            ___T: ::fidl_next::Transport,
19093        {
19094            #[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"]
19095            pub fn get_next(
19096                &self,
19097
19098                start_id: impl ::fidl_next::Encode<
19099                    <___T as ::fidl_next::Transport>::SendBuffer,
19100                    Encoded = ::fidl_next::WireU64,
19101                >,
19102
19103                limit: impl ::fidl_next::Encode<
19104                    <___T as ::fidl_next::Transport>::SendBuffer,
19105                    Encoded = ::fidl_next::WireU32,
19106                >,
19107            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19108            where
19109                <___T as ::fidl_next::Transport>::SendBuffer:
19110                    ::fidl_next::encoder::InternalHandleEncoder,
19111            {
19112                self.get_next_with(crate::generic::DictionaryDrainIteratorGetNextRequest {
19113                    start_id,
19114
19115                    limit,
19116                })
19117            }
19118
19119            #[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"]
19120            pub fn get_next_with<___R>(
19121                &self,
19122                request: ___R,
19123            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19124            where
19125                ___R: ::fidl_next::Encode<
19126                        <___T as ::fidl_next::Transport>::SendBuffer,
19127                        Encoded = crate::wire::DictionaryDrainIteratorGetNextRequest,
19128                    >,
19129            {
19130                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19131                    5728722530628427873,
19132                    <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19133                    request,
19134                ))
19135            }
19136        }
19137
19138        /// The server for the `DictionaryDrainIterator` protocol.
19139        #[repr(transparent)]
19140        pub struct DictionaryDrainIteratorServer<___T: ::fidl_next::Transport> {
19141            server: ::fidl_next::protocol::Server<___T>,
19142        }
19143
19144        impl<___T> DictionaryDrainIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19145    }
19146}
19147
19148/// A client handler for the DictionaryDrainIterator protocol.
19149///
19150/// See [`DictionaryDrainIterator`] for more details.
19151pub trait DictionaryDrainIteratorClientHandler<
19152    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19153    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19154>
19155{
19156    fn on_unknown_interaction(
19157        &mut self,
19158        ordinal: u64,
19159    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19160        ::core::future::ready(())
19161    }
19162}
19163
19164impl<___T> DictionaryDrainIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19165where
19166    ___T: ::fidl_next::Transport,
19167{
19168    async fn on_unknown_interaction(&mut self, _: u64) {}
19169}
19170
19171impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryDrainIterator
19172where
19173    ___H: DictionaryDrainIteratorClientHandler<___T> + ::core::marker::Send,
19174    ___T: ::fidl_next::Transport,
19175    <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Response:
19176        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19177{
19178    async fn on_event(
19179        handler: &mut ___H,
19180        ordinal: u64,
19181        flexibility: ::fidl_next::protocol::Flexibility,
19182        buffer: ___T::RecvBuffer,
19183    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19184        match ordinal {
19185            ordinal => {
19186                handler.on_unknown_interaction(ordinal).await;
19187                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19188                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19189                } else {
19190                    Ok(())
19191                }
19192            }
19193        }
19194    }
19195}
19196
19197/// A server handler for the DictionaryDrainIterator protocol.
19198///
19199/// See [`DictionaryDrainIterator`] for more details.
19200pub trait DictionaryDrainIteratorServerHandler<
19201    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19202    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19203>
19204{
19205    #[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"]
19206    fn get_next(
19207        &mut self,
19208
19209        request: ::fidl_next::Request<dictionary_drain_iterator::GetNext, ___T>,
19210
19211        responder: ::fidl_next::Responder<dictionary_drain_iterator::GetNext, ___T>,
19212    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19213
19214    fn on_unknown_interaction(
19215        &mut self,
19216        ordinal: u64,
19217    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19218        ::core::future::ready(())
19219    }
19220}
19221
19222impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryDrainIterator
19223where
19224    ___H: DictionaryDrainIteratorServerHandler<___T> + ::core::marker::Send,
19225    ___T: ::fidl_next::Transport,
19226    <dictionary_drain_iterator::GetNext as ::fidl_next::Method>::Request:
19227        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19228{
19229    async fn on_one_way(
19230        handler: &mut ___H,
19231        ordinal: u64,
19232        flexibility: ::fidl_next::protocol::Flexibility,
19233        buffer: ___T::RecvBuffer,
19234    ) -> ::core::result::Result<
19235        (),
19236        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19237    > {
19238        match ordinal {
19239            ordinal => {
19240                handler.on_unknown_interaction(ordinal).await;
19241                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19242                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19243                } else {
19244                    Ok(())
19245                }
19246            }
19247        }
19248    }
19249
19250    async fn on_two_way(
19251        handler: &mut ___H,
19252        ordinal: u64,
19253        flexibility: ::fidl_next::protocol::Flexibility,
19254        buffer: ___T::RecvBuffer,
19255        responder: ::fidl_next::protocol::Responder<___T>,
19256    ) -> ::core::result::Result<
19257        (),
19258        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19259    > {
19260        match ordinal {
19261            5728722530628427873 => {
19262                let responder = ::fidl_next::Responder::from_untyped(responder);
19263
19264                match ::fidl_next::DecoderExt::decode(buffer) {
19265                    Ok(decoded) => {
19266                        handler.get_next(decoded, responder).await;
19267                        Ok(())
19268                    }
19269                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19270                        ordinal: 5728722530628427873,
19271                        error,
19272                    }),
19273                }
19274            }
19275
19276            ordinal => {
19277                handler.on_unknown_interaction(ordinal).await;
19278                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19279                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19280                } else {
19281                    responder
19282                        .respond(
19283                            ordinal,
19284                            flexibility,
19285                            ::fidl_next::Flexible::<()>::FrameworkErr(
19286                                ::fidl_next::FrameworkError::UnknownMethod,
19287                            ),
19288                        )
19289                        .expect("encoding a framework error should never fail")
19290                        .await?;
19291                    Ok(())
19292                }
19293            }
19294        }
19295    }
19296}
19297
19298/// The type corresponding to the DictionaryEnumerateIterator protocol.
19299#[derive(PartialEq, Debug)]
19300pub struct DictionaryEnumerateIterator;
19301
19302#[cfg(target_os = "fuchsia")]
19303impl ::fidl_next::HasTransport for DictionaryEnumerateIterator {
19304    type Transport = ::fidl_next::fuchsia::zx::Channel;
19305}
19306
19307pub mod dictionary_enumerate_iterator {
19308    pub mod prelude {
19309        pub use crate::{
19310            DictionaryEnumerateIterator, DictionaryEnumerateIteratorClientHandler,
19311            DictionaryEnumerateIteratorServerHandler, dictionary_enumerate_iterator,
19312        };
19313
19314        pub use crate::natural::CapabilityStoreError;
19315
19316        pub use crate::natural::DictionaryEnumerateIteratorGetNextRequest;
19317
19318        pub use crate::natural::DictionaryEnumerateIteratorGetNextResponse;
19319    }
19320
19321    pub struct GetNext;
19322
19323    impl ::fidl_next::Method for GetNext {
19324        const ORDINAL: u64 = 1511164556663256527;
19325        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19326            ::fidl_next::protocol::Flexibility::Flexible;
19327
19328        type Protocol = crate::DictionaryEnumerateIterator;
19329
19330        type Request = crate::wire::DictionaryEnumerateIteratorGetNextRequest;
19331
19332        type Response = ::fidl_next::WireFlexibleResult<
19333            'static,
19334            crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
19335            crate::wire::CapabilityStoreError,
19336        >;
19337    }
19338
19339    impl<___R> ::fidl_next::Respond<___R> for GetNext {
19340        type Output = ::fidl_next::FlexibleResult<
19341            ___R,
19342            ::fidl_next::util::EncodableNever<crate::wire::CapabilityStoreError>,
19343        >;
19344
19345        fn respond(response: ___R) -> Self::Output {
19346            ::fidl_next::FlexibleResult::Ok(response)
19347        }
19348    }
19349
19350    impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
19351        type Output = ::fidl_next::FlexibleResult<
19352            ::fidl_next::util::EncodableNever<
19353                crate::wire::DictionaryEnumerateIteratorGetNextResponse<'static>,
19354            >,
19355            ___R,
19356        >;
19357
19358        fn respond_err(response: ___R) -> Self::Output {
19359            ::fidl_next::FlexibleResult::Err(response)
19360        }
19361    }
19362
19363    mod ___detail {
19364        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryEnumerateIterator
19365        where
19366            ___T: ::fidl_next::Transport,
19367        {
19368            type Client = DictionaryEnumerateIteratorClient<___T>;
19369            type Server = DictionaryEnumerateIteratorServer<___T>;
19370        }
19371
19372        /// The client for the `DictionaryEnumerateIterator` protocol.
19373        #[repr(transparent)]
19374        pub struct DictionaryEnumerateIteratorClient<___T: ::fidl_next::Transport> {
19375            #[allow(dead_code)]
19376            client: ::fidl_next::protocol::Client<___T>,
19377        }
19378
19379        impl<___T> DictionaryEnumerateIteratorClient<___T>
19380        where
19381            ___T: ::fidl_next::Transport,
19382        {
19383            #[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"]
19384            pub fn get_next(
19385                &self,
19386
19387                start_id: impl ::fidl_next::Encode<
19388                    <___T as ::fidl_next::Transport>::SendBuffer,
19389                    Encoded = ::fidl_next::WireU64,
19390                >,
19391
19392                limit: impl ::fidl_next::Encode<
19393                    <___T as ::fidl_next::Transport>::SendBuffer,
19394                    Encoded = ::fidl_next::WireU32,
19395                >,
19396            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19397            where
19398                <___T as ::fidl_next::Transport>::SendBuffer:
19399                    ::fidl_next::encoder::InternalHandleEncoder,
19400            {
19401                self.get_next_with(crate::generic::DictionaryEnumerateIteratorGetNextRequest {
19402                    start_id,
19403
19404                    limit,
19405                })
19406            }
19407
19408            #[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"]
19409            pub fn get_next_with<___R>(
19410                &self,
19411                request: ___R,
19412            ) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T>
19413            where
19414                ___R: ::fidl_next::Encode<
19415                        <___T as ::fidl_next::Transport>::SendBuffer,
19416                        Encoded = crate::wire::DictionaryEnumerateIteratorGetNextRequest,
19417                    >,
19418            {
19419                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19420                    1511164556663256527,
19421                    <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19422                    request,
19423                ))
19424            }
19425        }
19426
19427        /// The server for the `DictionaryEnumerateIterator` protocol.
19428        #[repr(transparent)]
19429        pub struct DictionaryEnumerateIteratorServer<___T: ::fidl_next::Transport> {
19430            server: ::fidl_next::protocol::Server<___T>,
19431        }
19432
19433        impl<___T> DictionaryEnumerateIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19434    }
19435}
19436
19437/// A client handler for the DictionaryEnumerateIterator protocol.
19438///
19439/// See [`DictionaryEnumerateIterator`] for more details.
19440pub trait DictionaryEnumerateIteratorClientHandler<
19441    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19442    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19443>
19444{
19445    fn on_unknown_interaction(
19446        &mut self,
19447        ordinal: u64,
19448    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19449        ::core::future::ready(())
19450    }
19451}
19452
19453impl<___T> DictionaryEnumerateIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19454where
19455    ___T: ::fidl_next::Transport,
19456{
19457    async fn on_unknown_interaction(&mut self, _: u64) {}
19458}
19459
19460impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryEnumerateIterator
19461where
19462    ___H: DictionaryEnumerateIteratorClientHandler<___T> + ::core::marker::Send,
19463    ___T: ::fidl_next::Transport,
19464    <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Response:
19465        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19466{
19467    async fn on_event(
19468        handler: &mut ___H,
19469        ordinal: u64,
19470        flexibility: ::fidl_next::protocol::Flexibility,
19471        buffer: ___T::RecvBuffer,
19472    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19473        match ordinal {
19474            ordinal => {
19475                handler.on_unknown_interaction(ordinal).await;
19476                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19477                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19478                } else {
19479                    Ok(())
19480                }
19481            }
19482        }
19483    }
19484}
19485
19486/// A server handler for the DictionaryEnumerateIterator protocol.
19487///
19488/// See [`DictionaryEnumerateIterator`] for more details.
19489pub trait DictionaryEnumerateIteratorServerHandler<
19490    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19491    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19492>
19493{
19494    #[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"]
19495    fn get_next(
19496        &mut self,
19497
19498        request: ::fidl_next::Request<dictionary_enumerate_iterator::GetNext, ___T>,
19499
19500        responder: ::fidl_next::Responder<dictionary_enumerate_iterator::GetNext, ___T>,
19501    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19502
19503    fn on_unknown_interaction(
19504        &mut self,
19505        ordinal: u64,
19506    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19507        ::core::future::ready(())
19508    }
19509}
19510
19511impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryEnumerateIterator
19512where
19513    ___H: DictionaryEnumerateIteratorServerHandler<___T> + ::core::marker::Send,
19514    ___T: ::fidl_next::Transport,
19515    <dictionary_enumerate_iterator::GetNext as ::fidl_next::Method>::Request:
19516        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19517{
19518    async fn on_one_way(
19519        handler: &mut ___H,
19520        ordinal: u64,
19521        flexibility: ::fidl_next::protocol::Flexibility,
19522        buffer: ___T::RecvBuffer,
19523    ) -> ::core::result::Result<
19524        (),
19525        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19526    > {
19527        match ordinal {
19528            ordinal => {
19529                handler.on_unknown_interaction(ordinal).await;
19530                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19531                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19532                } else {
19533                    Ok(())
19534                }
19535            }
19536        }
19537    }
19538
19539    async fn on_two_way(
19540        handler: &mut ___H,
19541        ordinal: u64,
19542        flexibility: ::fidl_next::protocol::Flexibility,
19543        buffer: ___T::RecvBuffer,
19544        responder: ::fidl_next::protocol::Responder<___T>,
19545    ) -> ::core::result::Result<
19546        (),
19547        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19548    > {
19549        match ordinal {
19550            1511164556663256527 => {
19551                let responder = ::fidl_next::Responder::from_untyped(responder);
19552
19553                match ::fidl_next::DecoderExt::decode(buffer) {
19554                    Ok(decoded) => {
19555                        handler.get_next(decoded, responder).await;
19556                        Ok(())
19557                    }
19558                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19559                        ordinal: 1511164556663256527,
19560                        error,
19561                    }),
19562                }
19563            }
19564
19565            ordinal => {
19566                handler.on_unknown_interaction(ordinal).await;
19567                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19568                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19569                } else {
19570                    responder
19571                        .respond(
19572                            ordinal,
19573                            flexibility,
19574                            ::fidl_next::Flexible::<()>::FrameworkErr(
19575                                ::fidl_next::FrameworkError::UnknownMethod,
19576                            ),
19577                        )
19578                        .expect("encoding a framework error should never fail")
19579                        .await?;
19580                    Ok(())
19581                }
19582            }
19583        }
19584    }
19585}
19586
19587/// The type corresponding to the DictionaryKeysIterator protocol.
19588#[derive(PartialEq, Debug)]
19589pub struct DictionaryKeysIterator;
19590
19591#[cfg(target_os = "fuchsia")]
19592impl ::fidl_next::HasTransport for DictionaryKeysIterator {
19593    type Transport = ::fidl_next::fuchsia::zx::Channel;
19594}
19595
19596pub mod dictionary_keys_iterator {
19597    pub mod prelude {
19598        pub use crate::{
19599            DictionaryKeysIterator, DictionaryKeysIteratorClientHandler,
19600            DictionaryKeysIteratorServerHandler, dictionary_keys_iterator,
19601        };
19602
19603        pub use crate::natural::DictionaryKeysIteratorGetNextResponse;
19604    }
19605
19606    pub struct GetNext;
19607
19608    impl ::fidl_next::Method for GetNext {
19609        const ORDINAL: u64 = 4987781442555247955;
19610        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19611            ::fidl_next::protocol::Flexibility::Flexible;
19612
19613        type Protocol = crate::DictionaryKeysIterator;
19614
19615        type Request = ();
19616
19617        type Response = ::fidl_next::WireFlexible<
19618            'static,
19619            crate::wire::DictionaryKeysIteratorGetNextResponse<'static>,
19620        >;
19621    }
19622
19623    impl<___R> ::fidl_next::Respond<___R> for GetNext {
19624        type Output =
19625            ::fidl_next::Flexible<crate::generic::DictionaryKeysIteratorGetNextResponse<___R>>;
19626
19627        fn respond(response: ___R) -> Self::Output {
19628            ::fidl_next::Flexible::Ok(crate::generic::DictionaryKeysIteratorGetNextResponse {
19629                keys: response,
19630            })
19631        }
19632    }
19633
19634    mod ___detail {
19635        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryKeysIterator
19636        where
19637            ___T: ::fidl_next::Transport,
19638        {
19639            type Client = DictionaryKeysIteratorClient<___T>;
19640            type Server = DictionaryKeysIteratorServer<___T>;
19641        }
19642
19643        /// The client for the `DictionaryKeysIterator` protocol.
19644        #[repr(transparent)]
19645        pub struct DictionaryKeysIteratorClient<___T: ::fidl_next::Transport> {
19646            #[allow(dead_code)]
19647            client: ::fidl_next::protocol::Client<___T>,
19648        }
19649
19650        impl<___T> DictionaryKeysIteratorClient<___T>
19651        where
19652            ___T: ::fidl_next::Transport,
19653        {
19654            pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
19655                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19656                    4987781442555247955,
19657                    <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
19658                    (),
19659                ))
19660            }
19661        }
19662
19663        /// The server for the `DictionaryKeysIterator` protocol.
19664        #[repr(transparent)]
19665        pub struct DictionaryKeysIteratorServer<___T: ::fidl_next::Transport> {
19666            server: ::fidl_next::protocol::Server<___T>,
19667        }
19668
19669        impl<___T> DictionaryKeysIteratorServer<___T> where ___T: ::fidl_next::Transport {}
19670    }
19671}
19672
19673/// A client handler for the DictionaryKeysIterator protocol.
19674///
19675/// See [`DictionaryKeysIterator`] for more details.
19676pub trait DictionaryKeysIteratorClientHandler<
19677    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19678    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19679>
19680{
19681    fn on_unknown_interaction(
19682        &mut self,
19683        ordinal: u64,
19684    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19685        ::core::future::ready(())
19686    }
19687}
19688
19689impl<___T> DictionaryKeysIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents
19690where
19691    ___T: ::fidl_next::Transport,
19692{
19693    async fn on_unknown_interaction(&mut self, _: u64) {}
19694}
19695
19696impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryKeysIterator
19697where
19698    ___H: DictionaryKeysIteratorClientHandler<___T> + ::core::marker::Send,
19699    ___T: ::fidl_next::Transport,
19700    <dictionary_keys_iterator::GetNext as ::fidl_next::Method>::Response:
19701        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19702{
19703    async fn on_event(
19704        handler: &mut ___H,
19705        ordinal: u64,
19706        flexibility: ::fidl_next::protocol::Flexibility,
19707        buffer: ___T::RecvBuffer,
19708    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19709        match ordinal {
19710            ordinal => {
19711                handler.on_unknown_interaction(ordinal).await;
19712                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19713                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19714                } else {
19715                    Ok(())
19716                }
19717            }
19718        }
19719    }
19720}
19721
19722/// A server handler for the DictionaryKeysIterator protocol.
19723///
19724/// See [`DictionaryKeysIterator`] for more details.
19725pub trait DictionaryKeysIteratorServerHandler<
19726    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19727    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19728>
19729{
19730    fn get_next(
19731        &mut self,
19732
19733        responder: ::fidl_next::Responder<dictionary_keys_iterator::GetNext, ___T>,
19734    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19735
19736    fn on_unknown_interaction(
19737        &mut self,
19738        ordinal: u64,
19739    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19740        ::core::future::ready(())
19741    }
19742}
19743
19744impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryKeysIterator
19745where
19746    ___H: DictionaryKeysIteratorServerHandler<___T> + ::core::marker::Send,
19747    ___T: ::fidl_next::Transport,
19748{
19749    async fn on_one_way(
19750        handler: &mut ___H,
19751        ordinal: u64,
19752        flexibility: ::fidl_next::protocol::Flexibility,
19753        buffer: ___T::RecvBuffer,
19754    ) -> ::core::result::Result<
19755        (),
19756        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19757    > {
19758        match ordinal {
19759            ordinal => {
19760                handler.on_unknown_interaction(ordinal).await;
19761                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19762                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19763                } else {
19764                    Ok(())
19765                }
19766            }
19767        }
19768    }
19769
19770    async fn on_two_way(
19771        handler: &mut ___H,
19772        ordinal: u64,
19773        flexibility: ::fidl_next::protocol::Flexibility,
19774        buffer: ___T::RecvBuffer,
19775        responder: ::fidl_next::protocol::Responder<___T>,
19776    ) -> ::core::result::Result<
19777        (),
19778        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19779    > {
19780        match ordinal {
19781            4987781442555247955 => {
19782                let responder = ::fidl_next::Responder::from_untyped(responder);
19783
19784                handler.get_next(responder).await;
19785                Ok(())
19786            }
19787
19788            ordinal => {
19789                handler.on_unknown_interaction(ordinal).await;
19790                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19791                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19792                } else {
19793                    responder
19794                        .respond(
19795                            ordinal,
19796                            flexibility,
19797                            ::fidl_next::Flexible::<()>::FrameworkErr(
19798                                ::fidl_next::FrameworkError::UnknownMethod,
19799                            ),
19800                        )
19801                        .expect("encoding a framework error should never fail")
19802                        .await?;
19803                    Ok(())
19804                }
19805            }
19806        }
19807    }
19808}
19809
19810/// The type corresponding to the DictionaryRouter protocol.
19811#[derive(PartialEq, Debug)]
19812pub struct DictionaryRouter;
19813
19814impl ::fidl_next::Discoverable for DictionaryRouter {
19815    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DictionaryRouter";
19816}
19817
19818#[cfg(target_os = "fuchsia")]
19819impl ::fidl_next::HasTransport for DictionaryRouter {
19820    type Transport = ::fidl_next::fuchsia::zx::Channel;
19821}
19822
19823pub mod dictionary_router {
19824    pub mod prelude {
19825        pub use crate::{
19826            DictionaryRouter, DictionaryRouterClientHandler, DictionaryRouterServerHandler,
19827            dictionary_router,
19828        };
19829
19830        pub use crate::natural::DictionaryRouterRouteResponse;
19831
19832        pub use crate::natural::RouteRequest;
19833
19834        pub use crate::natural::RouterError;
19835    }
19836
19837    pub struct Route;
19838
19839    impl ::fidl_next::Method for Route {
19840        const ORDINAL: u64 = 8164012099375978399;
19841        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
19842            ::fidl_next::protocol::Flexibility::Flexible;
19843
19844        type Protocol = crate::DictionaryRouter;
19845
19846        type Request = crate::wire::RouteRequest<'static>;
19847
19848        type Response = ::fidl_next::WireFlexibleResult<
19849            'static,
19850            crate::wire::DictionaryRouterRouteResponse,
19851            crate::wire::RouterError,
19852        >;
19853    }
19854
19855    impl<___R> ::fidl_next::Respond<___R> for Route {
19856        type Output = ::fidl_next::FlexibleResult<
19857            ___R,
19858            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
19859        >;
19860
19861        fn respond(response: ___R) -> Self::Output {
19862            ::fidl_next::FlexibleResult::Ok(response)
19863        }
19864    }
19865
19866    impl<___R> ::fidl_next::RespondErr<___R> for Route {
19867        type Output = ::fidl_next::FlexibleResult<
19868            ::fidl_next::util::EncodableNever<crate::wire::DictionaryRouterRouteResponse>,
19869            ___R,
19870        >;
19871
19872        fn respond_err(response: ___R) -> Self::Output {
19873            ::fidl_next::FlexibleResult::Err(response)
19874        }
19875    }
19876
19877    mod ___detail {
19878        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DictionaryRouter
19879        where
19880            ___T: ::fidl_next::Transport,
19881        {
19882            type Client = DictionaryRouterClient<___T>;
19883            type Server = DictionaryRouterServer<___T>;
19884        }
19885
19886        /// The client for the `DictionaryRouter` protocol.
19887        #[repr(transparent)]
19888        pub struct DictionaryRouterClient<___T: ::fidl_next::Transport> {
19889            #[allow(dead_code)]
19890            client: ::fidl_next::protocol::Client<___T>,
19891        }
19892
19893        impl<___T> DictionaryRouterClient<___T>
19894        where
19895            ___T: ::fidl_next::Transport,
19896        {
19897            pub fn route_with<___R>(
19898                &self,
19899                request: ___R,
19900            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
19901            where
19902                ___R: ::fidl_next::Encode<
19903                        <___T as ::fidl_next::Transport>::SendBuffer,
19904                        Encoded = crate::wire::RouteRequest<'static>,
19905                    >,
19906            {
19907                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
19908                    8164012099375978399,
19909                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
19910                    request,
19911                ))
19912            }
19913        }
19914
19915        /// The server for the `DictionaryRouter` protocol.
19916        #[repr(transparent)]
19917        pub struct DictionaryRouterServer<___T: ::fidl_next::Transport> {
19918            server: ::fidl_next::protocol::Server<___T>,
19919        }
19920
19921        impl<___T> DictionaryRouterServer<___T> where ___T: ::fidl_next::Transport {}
19922    }
19923}
19924
19925/// A client handler for the DictionaryRouter protocol.
19926///
19927/// See [`DictionaryRouter`] for more details.
19928pub trait DictionaryRouterClientHandler<
19929    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19930    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19931>
19932{
19933    fn on_unknown_interaction(
19934        &mut self,
19935        ordinal: u64,
19936    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19937        ::core::future::ready(())
19938    }
19939}
19940
19941impl<___T> DictionaryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
19942where
19943    ___T: ::fidl_next::Transport,
19944{
19945    async fn on_unknown_interaction(&mut self, _: u64) {}
19946}
19947
19948impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DictionaryRouter
19949where
19950    ___H: DictionaryRouterClientHandler<___T> + ::core::marker::Send,
19951    ___T: ::fidl_next::Transport,
19952    <dictionary_router::Route as ::fidl_next::Method>::Response:
19953        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
19954{
19955    async fn on_event(
19956        handler: &mut ___H,
19957        ordinal: u64,
19958        flexibility: ::fidl_next::protocol::Flexibility,
19959        buffer: ___T::RecvBuffer,
19960    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19961        match ordinal {
19962            ordinal => {
19963                handler.on_unknown_interaction(ordinal).await;
19964                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
19965                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19966                } else {
19967                    Ok(())
19968                }
19969            }
19970        }
19971    }
19972}
19973
19974/// A server handler for the DictionaryRouter protocol.
19975///
19976/// See [`DictionaryRouter`] for more details.
19977pub trait DictionaryRouterServerHandler<
19978    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19979    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19980>
19981{
19982    fn route(
19983        &mut self,
19984
19985        request: ::fidl_next::Request<dictionary_router::Route, ___T>,
19986
19987        responder: ::fidl_next::Responder<dictionary_router::Route, ___T>,
19988    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19989
19990    fn on_unknown_interaction(
19991        &mut self,
19992        ordinal: u64,
19993    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19994        ::core::future::ready(())
19995    }
19996}
19997
19998impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DictionaryRouter
19999where
20000    ___H: DictionaryRouterServerHandler<___T> + ::core::marker::Send,
20001    ___T: ::fidl_next::Transport,
20002    <dictionary_router::Route as ::fidl_next::Method>::Request:
20003        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20004{
20005    async fn on_one_way(
20006        handler: &mut ___H,
20007        ordinal: u64,
20008        flexibility: ::fidl_next::protocol::Flexibility,
20009        buffer: ___T::RecvBuffer,
20010    ) -> ::core::result::Result<
20011        (),
20012        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20013    > {
20014        match ordinal {
20015            ordinal => {
20016                handler.on_unknown_interaction(ordinal).await;
20017                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20018                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20019                } else {
20020                    Ok(())
20021                }
20022            }
20023        }
20024    }
20025
20026    async fn on_two_way(
20027        handler: &mut ___H,
20028        ordinal: u64,
20029        flexibility: ::fidl_next::protocol::Flexibility,
20030        buffer: ___T::RecvBuffer,
20031        responder: ::fidl_next::protocol::Responder<___T>,
20032    ) -> ::core::result::Result<
20033        (),
20034        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20035    > {
20036        match ordinal {
20037            8164012099375978399 => {
20038                let responder = ::fidl_next::Responder::from_untyped(responder);
20039
20040                match ::fidl_next::DecoderExt::decode(buffer) {
20041                    Ok(decoded) => {
20042                        handler.route(decoded, responder).await;
20043                        Ok(())
20044                    }
20045                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20046                        ordinal: 8164012099375978399,
20047                        error,
20048                    }),
20049                }
20050            }
20051
20052            ordinal => {
20053                handler.on_unknown_interaction(ordinal).await;
20054                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20055                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20056                } else {
20057                    responder
20058                        .respond(
20059                            ordinal,
20060                            flexibility,
20061                            ::fidl_next::Flexible::<()>::FrameworkErr(
20062                                ::fidl_next::FrameworkError::UnknownMethod,
20063                            ),
20064                        )
20065                        .expect("encoding a framework error should never fail")
20066                        .await?;
20067                    Ok(())
20068                }
20069            }
20070        }
20071    }
20072}
20073
20074/// The type corresponding to the DirConnectorRouter protocol.
20075#[derive(PartialEq, Debug)]
20076pub struct DirConnectorRouter;
20077
20078impl ::fidl_next::Discoverable for DirConnectorRouter {
20079    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirConnectorRouter";
20080}
20081
20082#[cfg(target_os = "fuchsia")]
20083impl ::fidl_next::HasTransport for DirConnectorRouter {
20084    type Transport = ::fidl_next::fuchsia::zx::Channel;
20085}
20086
20087pub mod dir_connector_router {
20088    pub mod prelude {
20089        pub use crate::{
20090            DirConnectorRouter, DirConnectorRouterClientHandler, DirConnectorRouterServerHandler,
20091            dir_connector_router,
20092        };
20093
20094        pub use crate::natural::DirConnectorRouterRouteResponse;
20095
20096        pub use crate::natural::RouteRequest;
20097
20098        pub use crate::natural::RouterError;
20099    }
20100
20101    pub struct Route;
20102
20103    impl ::fidl_next::Method for Route {
20104        const ORDINAL: u64 = 972231070188342848;
20105        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20106            ::fidl_next::protocol::Flexibility::Flexible;
20107
20108        type Protocol = crate::DirConnectorRouter;
20109
20110        type Request = crate::wire::RouteRequest<'static>;
20111
20112        type Response = ::fidl_next::WireFlexibleResult<
20113            'static,
20114            crate::wire::DirConnectorRouterRouteResponse,
20115            crate::wire::RouterError,
20116        >;
20117    }
20118
20119    impl<___R> ::fidl_next::Respond<___R> for Route {
20120        type Output = ::fidl_next::FlexibleResult<
20121            ___R,
20122            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20123        >;
20124
20125        fn respond(response: ___R) -> Self::Output {
20126            ::fidl_next::FlexibleResult::Ok(response)
20127        }
20128    }
20129
20130    impl<___R> ::fidl_next::RespondErr<___R> for Route {
20131        type Output = ::fidl_next::FlexibleResult<
20132            ::fidl_next::util::EncodableNever<crate::wire::DirConnectorRouterRouteResponse>,
20133            ___R,
20134        >;
20135
20136        fn respond_err(response: ___R) -> Self::Output {
20137            ::fidl_next::FlexibleResult::Err(response)
20138        }
20139    }
20140
20141    mod ___detail {
20142        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirConnectorRouter
20143        where
20144            ___T: ::fidl_next::Transport,
20145        {
20146            type Client = DirConnectorRouterClient<___T>;
20147            type Server = DirConnectorRouterServer<___T>;
20148        }
20149
20150        /// The client for the `DirConnectorRouter` protocol.
20151        #[repr(transparent)]
20152        pub struct DirConnectorRouterClient<___T: ::fidl_next::Transport> {
20153            #[allow(dead_code)]
20154            client: ::fidl_next::protocol::Client<___T>,
20155        }
20156
20157        impl<___T> DirConnectorRouterClient<___T>
20158        where
20159            ___T: ::fidl_next::Transport,
20160        {
20161            pub fn route_with<___R>(
20162                &self,
20163                request: ___R,
20164            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20165            where
20166                ___R: ::fidl_next::Encode<
20167                        <___T as ::fidl_next::Transport>::SendBuffer,
20168                        Encoded = crate::wire::RouteRequest<'static>,
20169                    >,
20170            {
20171                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20172                    972231070188342848,
20173                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20174                    request,
20175                ))
20176            }
20177        }
20178
20179        /// The server for the `DirConnectorRouter` protocol.
20180        #[repr(transparent)]
20181        pub struct DirConnectorRouterServer<___T: ::fidl_next::Transport> {
20182            server: ::fidl_next::protocol::Server<___T>,
20183        }
20184
20185        impl<___T> DirConnectorRouterServer<___T> where ___T: ::fidl_next::Transport {}
20186    }
20187}
20188
20189/// A client handler for the DirConnectorRouter protocol.
20190///
20191/// See [`DirConnectorRouter`] for more details.
20192pub trait DirConnectorRouterClientHandler<
20193    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20194    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20195>
20196{
20197    fn on_unknown_interaction(
20198        &mut self,
20199        ordinal: u64,
20200    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20201        ::core::future::ready(())
20202    }
20203}
20204
20205impl<___T> DirConnectorRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20206where
20207    ___T: ::fidl_next::Transport,
20208{
20209    async fn on_unknown_interaction(&mut self, _: u64) {}
20210}
20211
20212impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirConnectorRouter
20213where
20214    ___H: DirConnectorRouterClientHandler<___T> + ::core::marker::Send,
20215    ___T: ::fidl_next::Transport,
20216    <dir_connector_router::Route as ::fidl_next::Method>::Response:
20217        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20218{
20219    async fn on_event(
20220        handler: &mut ___H,
20221        ordinal: u64,
20222        flexibility: ::fidl_next::protocol::Flexibility,
20223        buffer: ___T::RecvBuffer,
20224    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20225        match ordinal {
20226            ordinal => {
20227                handler.on_unknown_interaction(ordinal).await;
20228                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20229                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20230                } else {
20231                    Ok(())
20232                }
20233            }
20234        }
20235    }
20236}
20237
20238/// A server handler for the DirConnectorRouter protocol.
20239///
20240/// See [`DirConnectorRouter`] for more details.
20241pub trait DirConnectorRouterServerHandler<
20242    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20243    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20244>
20245{
20246    fn route(
20247        &mut self,
20248
20249        request: ::fidl_next::Request<dir_connector_router::Route, ___T>,
20250
20251        responder: ::fidl_next::Responder<dir_connector_router::Route, ___T>,
20252    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20253
20254    fn on_unknown_interaction(
20255        &mut self,
20256        ordinal: u64,
20257    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20258        ::core::future::ready(())
20259    }
20260}
20261
20262impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirConnectorRouter
20263where
20264    ___H: DirConnectorRouterServerHandler<___T> + ::core::marker::Send,
20265    ___T: ::fidl_next::Transport,
20266    <dir_connector_router::Route as ::fidl_next::Method>::Request:
20267        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20268{
20269    async fn on_one_way(
20270        handler: &mut ___H,
20271        ordinal: u64,
20272        flexibility: ::fidl_next::protocol::Flexibility,
20273        buffer: ___T::RecvBuffer,
20274    ) -> ::core::result::Result<
20275        (),
20276        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20277    > {
20278        match ordinal {
20279            ordinal => {
20280                handler.on_unknown_interaction(ordinal).await;
20281                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20282                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20283                } else {
20284                    Ok(())
20285                }
20286            }
20287        }
20288    }
20289
20290    async fn on_two_way(
20291        handler: &mut ___H,
20292        ordinal: u64,
20293        flexibility: ::fidl_next::protocol::Flexibility,
20294        buffer: ___T::RecvBuffer,
20295        responder: ::fidl_next::protocol::Responder<___T>,
20296    ) -> ::core::result::Result<
20297        (),
20298        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20299    > {
20300        match ordinal {
20301            972231070188342848 => {
20302                let responder = ::fidl_next::Responder::from_untyped(responder);
20303
20304                match ::fidl_next::DecoderExt::decode(buffer) {
20305                    Ok(decoded) => {
20306                        handler.route(decoded, responder).await;
20307                        Ok(())
20308                    }
20309                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20310                        ordinal: 972231070188342848,
20311                        error,
20312                    }),
20313                }
20314            }
20315
20316            ordinal => {
20317                handler.on_unknown_interaction(ordinal).await;
20318                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20319                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20320                } else {
20321                    responder
20322                        .respond(
20323                            ordinal,
20324                            flexibility,
20325                            ::fidl_next::Flexible::<()>::FrameworkErr(
20326                                ::fidl_next::FrameworkError::UnknownMethod,
20327                            ),
20328                        )
20329                        .expect("encoding a framework error should never fail")
20330                        .await?;
20331                    Ok(())
20332                }
20333            }
20334        }
20335    }
20336}
20337
20338/// The type corresponding to the DirEntryRouter protocol.
20339#[derive(PartialEq, Debug)]
20340pub struct DirEntryRouter;
20341
20342impl ::fidl_next::Discoverable for DirEntryRouter {
20343    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirEntryRouter";
20344}
20345
20346#[cfg(target_os = "fuchsia")]
20347impl ::fidl_next::HasTransport for DirEntryRouter {
20348    type Transport = ::fidl_next::fuchsia::zx::Channel;
20349}
20350
20351pub mod dir_entry_router {
20352    pub mod prelude {
20353        pub use crate::{
20354            DirEntryRouter, DirEntryRouterClientHandler, DirEntryRouterServerHandler,
20355            dir_entry_router,
20356        };
20357
20358        pub use crate::natural::DirEntryRouterRouteResponse;
20359
20360        pub use crate::natural::RouteRequest;
20361
20362        pub use crate::natural::RouterError;
20363    }
20364
20365    pub struct Route;
20366
20367    impl ::fidl_next::Method for Route {
20368        const ORDINAL: u64 = 1929392218567642066;
20369        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20370            ::fidl_next::protocol::Flexibility::Flexible;
20371
20372        type Protocol = crate::DirEntryRouter;
20373
20374        type Request = crate::wire::RouteRequest<'static>;
20375
20376        type Response = ::fidl_next::WireFlexibleResult<
20377            'static,
20378            crate::wire::DirEntryRouterRouteResponse,
20379            crate::wire::RouterError,
20380        >;
20381    }
20382
20383    impl<___R> ::fidl_next::Respond<___R> for Route {
20384        type Output = ::fidl_next::FlexibleResult<
20385            ___R,
20386            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20387        >;
20388
20389        fn respond(response: ___R) -> Self::Output {
20390            ::fidl_next::FlexibleResult::Ok(response)
20391        }
20392    }
20393
20394    impl<___R> ::fidl_next::RespondErr<___R> for Route {
20395        type Output = ::fidl_next::FlexibleResult<
20396            ::fidl_next::util::EncodableNever<crate::wire::DirEntryRouterRouteResponse>,
20397            ___R,
20398        >;
20399
20400        fn respond_err(response: ___R) -> Self::Output {
20401            ::fidl_next::FlexibleResult::Err(response)
20402        }
20403    }
20404
20405    mod ___detail {
20406        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirEntryRouter
20407        where
20408            ___T: ::fidl_next::Transport,
20409        {
20410            type Client = DirEntryRouterClient<___T>;
20411            type Server = DirEntryRouterServer<___T>;
20412        }
20413
20414        /// The client for the `DirEntryRouter` protocol.
20415        #[repr(transparent)]
20416        pub struct DirEntryRouterClient<___T: ::fidl_next::Transport> {
20417            #[allow(dead_code)]
20418            client: ::fidl_next::protocol::Client<___T>,
20419        }
20420
20421        impl<___T> DirEntryRouterClient<___T>
20422        where
20423            ___T: ::fidl_next::Transport,
20424        {
20425            pub fn route_with<___R>(
20426                &self,
20427                request: ___R,
20428            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20429            where
20430                ___R: ::fidl_next::Encode<
20431                        <___T as ::fidl_next::Transport>::SendBuffer,
20432                        Encoded = crate::wire::RouteRequest<'static>,
20433                    >,
20434            {
20435                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20436                    1929392218567642066,
20437                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20438                    request,
20439                ))
20440            }
20441        }
20442
20443        /// The server for the `DirEntryRouter` protocol.
20444        #[repr(transparent)]
20445        pub struct DirEntryRouterServer<___T: ::fidl_next::Transport> {
20446            server: ::fidl_next::protocol::Server<___T>,
20447        }
20448
20449        impl<___T> DirEntryRouterServer<___T> where ___T: ::fidl_next::Transport {}
20450    }
20451}
20452
20453/// A client handler for the DirEntryRouter protocol.
20454///
20455/// See [`DirEntryRouter`] for more details.
20456pub trait DirEntryRouterClientHandler<
20457    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20458    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20459>
20460{
20461    fn on_unknown_interaction(
20462        &mut self,
20463        ordinal: u64,
20464    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20465        ::core::future::ready(())
20466    }
20467}
20468
20469impl<___T> DirEntryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20470where
20471    ___T: ::fidl_next::Transport,
20472{
20473    async fn on_unknown_interaction(&mut self, _: u64) {}
20474}
20475
20476impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirEntryRouter
20477where
20478    ___H: DirEntryRouterClientHandler<___T> + ::core::marker::Send,
20479    ___T: ::fidl_next::Transport,
20480    <dir_entry_router::Route as ::fidl_next::Method>::Response:
20481        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20482{
20483    async fn on_event(
20484        handler: &mut ___H,
20485        ordinal: u64,
20486        flexibility: ::fidl_next::protocol::Flexibility,
20487        buffer: ___T::RecvBuffer,
20488    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20489        match ordinal {
20490            ordinal => {
20491                handler.on_unknown_interaction(ordinal).await;
20492                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20493                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20494                } else {
20495                    Ok(())
20496                }
20497            }
20498        }
20499    }
20500}
20501
20502/// A server handler for the DirEntryRouter protocol.
20503///
20504/// See [`DirEntryRouter`] for more details.
20505pub trait DirEntryRouterServerHandler<
20506    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20507    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20508>
20509{
20510    fn route(
20511        &mut self,
20512
20513        request: ::fidl_next::Request<dir_entry_router::Route, ___T>,
20514
20515        responder: ::fidl_next::Responder<dir_entry_router::Route, ___T>,
20516    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20517
20518    fn on_unknown_interaction(
20519        &mut self,
20520        ordinal: u64,
20521    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20522        ::core::future::ready(())
20523    }
20524}
20525
20526impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirEntryRouter
20527where
20528    ___H: DirEntryRouterServerHandler<___T> + ::core::marker::Send,
20529    ___T: ::fidl_next::Transport,
20530    <dir_entry_router::Route as ::fidl_next::Method>::Request:
20531        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20532{
20533    async fn on_one_way(
20534        handler: &mut ___H,
20535        ordinal: u64,
20536        flexibility: ::fidl_next::protocol::Flexibility,
20537        buffer: ___T::RecvBuffer,
20538    ) -> ::core::result::Result<
20539        (),
20540        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20541    > {
20542        match ordinal {
20543            ordinal => {
20544                handler.on_unknown_interaction(ordinal).await;
20545                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20546                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20547                } else {
20548                    Ok(())
20549                }
20550            }
20551        }
20552    }
20553
20554    async fn on_two_way(
20555        handler: &mut ___H,
20556        ordinal: u64,
20557        flexibility: ::fidl_next::protocol::Flexibility,
20558        buffer: ___T::RecvBuffer,
20559        responder: ::fidl_next::protocol::Responder<___T>,
20560    ) -> ::core::result::Result<
20561        (),
20562        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20563    > {
20564        match ordinal {
20565            1929392218567642066 => {
20566                let responder = ::fidl_next::Responder::from_untyped(responder);
20567
20568                match ::fidl_next::DecoderExt::decode(buffer) {
20569                    Ok(decoded) => {
20570                        handler.route(decoded, responder).await;
20571                        Ok(())
20572                    }
20573                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20574                        ordinal: 1929392218567642066,
20575                        error,
20576                    }),
20577                }
20578            }
20579
20580            ordinal => {
20581                handler.on_unknown_interaction(ordinal).await;
20582                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20583                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20584                } else {
20585                    responder
20586                        .respond(
20587                            ordinal,
20588                            flexibility,
20589                            ::fidl_next::Flexible::<()>::FrameworkErr(
20590                                ::fidl_next::FrameworkError::UnknownMethod,
20591                            ),
20592                        )
20593                        .expect("encoding a framework error should never fail")
20594                        .await?;
20595                    Ok(())
20596                }
20597            }
20598        }
20599    }
20600}
20601
20602/// The type corresponding to the DirReceiver protocol.
20603#[doc = " A receiver is served by components and allows them to receive directory channels\n framework.\n"]
20604#[derive(PartialEq, Debug)]
20605pub struct DirReceiver;
20606
20607impl ::fidl_next::Discoverable for DirReceiver {
20608    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirReceiver";
20609}
20610
20611#[cfg(target_os = "fuchsia")]
20612impl ::fidl_next::HasTransport for DirReceiver {
20613    type Transport = ::fidl_next::fuchsia::zx::Channel;
20614}
20615
20616pub mod dir_receiver {
20617    pub mod prelude {
20618        pub use crate::{
20619            DirReceiver, DirReceiverClientHandler, DirReceiverServerHandler, dir_receiver,
20620        };
20621
20622        pub use crate::natural::DirReceiverReceiveRequest;
20623    }
20624
20625    pub struct Receive;
20626
20627    impl ::fidl_next::Method for Receive {
20628        const ORDINAL: u64 = 926684461087488948;
20629        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20630            ::fidl_next::protocol::Flexibility::Flexible;
20631
20632        type Protocol = crate::DirReceiver;
20633
20634        type Request = crate::wire::DirReceiverReceiveRequest;
20635
20636        type Response = ::fidl_next::util::Never;
20637    }
20638
20639    mod ___detail {
20640        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirReceiver
20641        where
20642            ___T: ::fidl_next::Transport,
20643        {
20644            type Client = DirReceiverClient<___T>;
20645            type Server = DirReceiverServer<___T>;
20646        }
20647
20648        /// The client for the `DirReceiver` protocol.
20649        #[repr(transparent)]
20650        pub struct DirReceiverClient<___T: ::fidl_next::Transport> {
20651            #[allow(dead_code)]
20652            client: ::fidl_next::protocol::Client<___T>,
20653        }
20654
20655        impl<___T> DirReceiverClient<___T>
20656        where
20657            ___T: ::fidl_next::Transport,
20658        {
20659            #[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"]
20660            pub fn receive(
20661                &self,
20662
20663                channel: impl ::fidl_next::Encode<
20664                    <___T as ::fidl_next::Transport>::SendBuffer,
20665                    Encoded = ::fidl_next::ServerEnd<
20666                        ::fidl_next_fuchsia_io::Directory,
20667                        ::fidl_next::fuchsia::WireChannel,
20668                    >,
20669                >,
20670            ) -> ::fidl_next::SendFuture<'_, ___T>
20671            where
20672                <___T as ::fidl_next::Transport>::SendBuffer:
20673                    ::fidl_next::encoder::InternalHandleEncoder,
20674                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
20675            {
20676                self.receive_with(crate::generic::DirReceiverReceiveRequest { channel })
20677            }
20678
20679            #[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"]
20680            pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
20681            where
20682                ___R: ::fidl_next::Encode<
20683                        <___T as ::fidl_next::Transport>::SendBuffer,
20684                        Encoded = crate::wire::DirReceiverReceiveRequest,
20685                    >,
20686            {
20687                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
20688                    926684461087488948,
20689                    <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
20690                    request,
20691                ))
20692            }
20693        }
20694
20695        /// The server for the `DirReceiver` protocol.
20696        #[repr(transparent)]
20697        pub struct DirReceiverServer<___T: ::fidl_next::Transport> {
20698            server: ::fidl_next::protocol::Server<___T>,
20699        }
20700
20701        impl<___T> DirReceiverServer<___T> where ___T: ::fidl_next::Transport {}
20702    }
20703}
20704
20705/// A client handler for the DirReceiver protocol.
20706///
20707/// See [`DirReceiver`] for more details.
20708pub trait DirReceiverClientHandler<
20709    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20710    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20711>
20712{
20713    fn on_unknown_interaction(
20714        &mut self,
20715        ordinal: u64,
20716    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20717        ::core::future::ready(())
20718    }
20719}
20720
20721impl<___T> DirReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
20722where
20723    ___T: ::fidl_next::Transport,
20724{
20725    async fn on_unknown_interaction(&mut self, _: u64) {}
20726}
20727
20728impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirReceiver
20729where
20730    ___H: DirReceiverClientHandler<___T> + ::core::marker::Send,
20731    ___T: ::fidl_next::Transport,
20732{
20733    async fn on_event(
20734        handler: &mut ___H,
20735        ordinal: u64,
20736        flexibility: ::fidl_next::protocol::Flexibility,
20737        buffer: ___T::RecvBuffer,
20738    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20739        match ordinal {
20740            ordinal => {
20741                handler.on_unknown_interaction(ordinal).await;
20742                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20743                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20744                } else {
20745                    Ok(())
20746                }
20747            }
20748        }
20749    }
20750}
20751
20752/// A server handler for the DirReceiver protocol.
20753///
20754/// See [`DirReceiver`] for more details.
20755pub trait DirReceiverServerHandler<
20756    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20757    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20758>
20759{
20760    #[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"]
20761    fn receive(
20762        &mut self,
20763
20764        request: ::fidl_next::Request<dir_receiver::Receive, ___T>,
20765    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20766
20767    fn on_unknown_interaction(
20768        &mut self,
20769        ordinal: u64,
20770    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20771        ::core::future::ready(())
20772    }
20773}
20774
20775impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirReceiver
20776where
20777    ___H: DirReceiverServerHandler<___T> + ::core::marker::Send,
20778    ___T: ::fidl_next::Transport,
20779    <dir_receiver::Receive as ::fidl_next::Method>::Request:
20780        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20781{
20782    async fn on_one_way(
20783        handler: &mut ___H,
20784        ordinal: u64,
20785        flexibility: ::fidl_next::protocol::Flexibility,
20786        buffer: ___T::RecvBuffer,
20787    ) -> ::core::result::Result<
20788        (),
20789        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20790    > {
20791        match ordinal {
20792            926684461087488948 => match ::fidl_next::DecoderExt::decode(buffer) {
20793                Ok(decoded) => {
20794                    handler.receive(decoded).await;
20795                    Ok(())
20796                }
20797                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20798                    ordinal: 926684461087488948,
20799                    error,
20800                }),
20801            },
20802
20803            ordinal => {
20804                handler.on_unknown_interaction(ordinal).await;
20805                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20806                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20807                } else {
20808                    Ok(())
20809                }
20810            }
20811        }
20812    }
20813
20814    async fn on_two_way(
20815        handler: &mut ___H,
20816        ordinal: u64,
20817        flexibility: ::fidl_next::protocol::Flexibility,
20818        buffer: ___T::RecvBuffer,
20819        responder: ::fidl_next::protocol::Responder<___T>,
20820    ) -> ::core::result::Result<
20821        (),
20822        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20823    > {
20824        match ordinal {
20825            ordinal => {
20826                handler.on_unknown_interaction(ordinal).await;
20827                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
20828                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20829                } else {
20830                    responder
20831                        .respond(
20832                            ordinal,
20833                            flexibility,
20834                            ::fidl_next::Flexible::<()>::FrameworkErr(
20835                                ::fidl_next::FrameworkError::UnknownMethod,
20836                            ),
20837                        )
20838                        .expect("encoding a framework error should never fail")
20839                        .await?;
20840                    Ok(())
20841                }
20842            }
20843        }
20844    }
20845}
20846
20847/// The type corresponding to the DirectoryRouter protocol.
20848#[derive(PartialEq, Debug)]
20849pub struct DirectoryRouter;
20850
20851impl ::fidl_next::Discoverable for DirectoryRouter {
20852    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.DirectoryRouter";
20853}
20854
20855#[cfg(target_os = "fuchsia")]
20856impl ::fidl_next::HasTransport for DirectoryRouter {
20857    type Transport = ::fidl_next::fuchsia::zx::Channel;
20858}
20859
20860pub mod directory_router {
20861    pub mod prelude {
20862        pub use crate::{
20863            DirectoryRouter, DirectoryRouterClientHandler, DirectoryRouterServerHandler,
20864            directory_router,
20865        };
20866
20867        pub use crate::natural::DirectoryRouterRouteResponse;
20868
20869        pub use crate::natural::RouteRequest;
20870
20871        pub use crate::natural::RouterError;
20872    }
20873
20874    pub struct Route;
20875
20876    impl ::fidl_next::Method for Route {
20877        const ORDINAL: u64 = 7510716014181158689;
20878        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
20879            ::fidl_next::protocol::Flexibility::Flexible;
20880
20881        type Protocol = crate::DirectoryRouter;
20882
20883        type Request = crate::wire::RouteRequest<'static>;
20884
20885        type Response = ::fidl_next::WireFlexibleResult<
20886            'static,
20887            crate::wire::DirectoryRouterRouteResponse,
20888            crate::wire::RouterError,
20889        >;
20890    }
20891
20892    impl<___R> ::fidl_next::Respond<___R> for Route {
20893        type Output = ::fidl_next::FlexibleResult<
20894            ___R,
20895            ::fidl_next::util::EncodableNever<crate::wire::RouterError>,
20896        >;
20897
20898        fn respond(response: ___R) -> Self::Output {
20899            ::fidl_next::FlexibleResult::Ok(response)
20900        }
20901    }
20902
20903    impl<___R> ::fidl_next::RespondErr<___R> for Route {
20904        type Output = ::fidl_next::FlexibleResult<
20905            ::fidl_next::util::EncodableNever<crate::wire::DirectoryRouterRouteResponse>,
20906            ___R,
20907        >;
20908
20909        fn respond_err(response: ___R) -> Self::Output {
20910            ::fidl_next::FlexibleResult::Err(response)
20911        }
20912    }
20913
20914    mod ___detail {
20915        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryRouter
20916        where
20917            ___T: ::fidl_next::Transport,
20918        {
20919            type Client = DirectoryRouterClient<___T>;
20920            type Server = DirectoryRouterServer<___T>;
20921        }
20922
20923        /// The client for the `DirectoryRouter` protocol.
20924        #[repr(transparent)]
20925        pub struct DirectoryRouterClient<___T: ::fidl_next::Transport> {
20926            #[allow(dead_code)]
20927            client: ::fidl_next::protocol::Client<___T>,
20928        }
20929
20930        impl<___T> DirectoryRouterClient<___T>
20931        where
20932            ___T: ::fidl_next::Transport,
20933        {
20934            pub fn route_with<___R>(
20935                &self,
20936                request: ___R,
20937            ) -> ::fidl_next::TwoWayFuture<'_, super::Route, ___T>
20938            where
20939                ___R: ::fidl_next::Encode<
20940                        <___T as ::fidl_next::Transport>::SendBuffer,
20941                        Encoded = crate::wire::RouteRequest<'static>,
20942                    >,
20943            {
20944                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
20945                    7510716014181158689,
20946                    <super::Route as ::fidl_next::Method>::FLEXIBILITY,
20947                    request,
20948                ))
20949            }
20950        }
20951
20952        /// The server for the `DirectoryRouter` protocol.
20953        #[repr(transparent)]
20954        pub struct DirectoryRouterServer<___T: ::fidl_next::Transport> {
20955            server: ::fidl_next::protocol::Server<___T>,
20956        }
20957
20958        impl<___T> DirectoryRouterServer<___T> where ___T: ::fidl_next::Transport {}
20959    }
20960}
20961
20962/// A client handler for the DirectoryRouter protocol.
20963///
20964/// See [`DirectoryRouter`] for more details.
20965pub trait DirectoryRouterClientHandler<
20966    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
20967    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
20968>
20969{
20970    fn on_unknown_interaction(
20971        &mut self,
20972        ordinal: u64,
20973    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20974        ::core::future::ready(())
20975    }
20976}
20977
20978impl<___T> DirectoryRouterClientHandler<___T> for ::fidl_next::IgnoreEvents
20979where
20980    ___T: ::fidl_next::Transport,
20981{
20982    async fn on_unknown_interaction(&mut self, _: u64) {}
20983}
20984
20985impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryRouter
20986where
20987    ___H: DirectoryRouterClientHandler<___T> + ::core::marker::Send,
20988    ___T: ::fidl_next::Transport,
20989    <directory_router::Route as ::fidl_next::Method>::Response:
20990        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
20991{
20992    async fn on_event(
20993        handler: &mut ___H,
20994        ordinal: u64,
20995        flexibility: ::fidl_next::protocol::Flexibility,
20996        buffer: ___T::RecvBuffer,
20997    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
20998        match ordinal {
20999            ordinal => {
21000                handler.on_unknown_interaction(ordinal).await;
21001                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21002                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21003                } else {
21004                    Ok(())
21005                }
21006            }
21007        }
21008    }
21009}
21010
21011/// A server handler for the DirectoryRouter protocol.
21012///
21013/// See [`DirectoryRouter`] for more details.
21014pub trait DirectoryRouterServerHandler<
21015    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21016    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21017>
21018{
21019    fn route(
21020        &mut self,
21021
21022        request: ::fidl_next::Request<directory_router::Route, ___T>,
21023
21024        responder: ::fidl_next::Responder<directory_router::Route, ___T>,
21025    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21026
21027    fn on_unknown_interaction(
21028        &mut self,
21029        ordinal: u64,
21030    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21031        ::core::future::ready(())
21032    }
21033}
21034
21035impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryRouter
21036where
21037    ___H: DirectoryRouterServerHandler<___T> + ::core::marker::Send,
21038    ___T: ::fidl_next::Transport,
21039    <directory_router::Route as ::fidl_next::Method>::Request:
21040        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
21041{
21042    async fn on_one_way(
21043        handler: &mut ___H,
21044        ordinal: u64,
21045        flexibility: ::fidl_next::protocol::Flexibility,
21046        buffer: ___T::RecvBuffer,
21047    ) -> ::core::result::Result<
21048        (),
21049        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21050    > {
21051        match ordinal {
21052            ordinal => {
21053                handler.on_unknown_interaction(ordinal).await;
21054                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21055                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21056                } else {
21057                    Ok(())
21058                }
21059            }
21060        }
21061    }
21062
21063    async fn on_two_way(
21064        handler: &mut ___H,
21065        ordinal: u64,
21066        flexibility: ::fidl_next::protocol::Flexibility,
21067        buffer: ___T::RecvBuffer,
21068        responder: ::fidl_next::protocol::Responder<___T>,
21069    ) -> ::core::result::Result<
21070        (),
21071        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21072    > {
21073        match ordinal {
21074            7510716014181158689 => {
21075                let responder = ::fidl_next::Responder::from_untyped(responder);
21076
21077                match ::fidl_next::DecoderExt::decode(buffer) {
21078                    Ok(decoded) => {
21079                        handler.route(decoded, responder).await;
21080                        Ok(())
21081                    }
21082                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21083                        ordinal: 7510716014181158689,
21084                        error,
21085                    }),
21086                }
21087            }
21088
21089            ordinal => {
21090                handler.on_unknown_interaction(ordinal).await;
21091                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21092                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21093                } else {
21094                    responder
21095                        .respond(
21096                            ordinal,
21097                            flexibility,
21098                            ::fidl_next::Flexible::<()>::FrameworkErr(
21099                                ::fidl_next::FrameworkError::UnknownMethod,
21100                            ),
21101                        )
21102                        .expect("encoding a framework error should never fail")
21103                        .await?;
21104                    Ok(())
21105                }
21106            }
21107        }
21108    }
21109}
21110
21111/// The type corresponding to the Receiver protocol.
21112#[doc = " A receiver is served by components and allows them to receive channels\n from the framework.\n"]
21113#[derive(PartialEq, Debug)]
21114pub struct Receiver;
21115
21116impl ::fidl_next::Discoverable for Receiver {
21117    const PROTOCOL_NAME: &'static str = "fuchsia.component.sandbox.Receiver";
21118}
21119
21120#[cfg(target_os = "fuchsia")]
21121impl ::fidl_next::HasTransport for Receiver {
21122    type Transport = ::fidl_next::fuchsia::zx::Channel;
21123}
21124
21125pub mod receiver {
21126    pub mod prelude {
21127        pub use crate::{Receiver, ReceiverClientHandler, ReceiverServerHandler, receiver};
21128
21129        pub use crate::natural::ProtocolPayload;
21130    }
21131
21132    pub struct Receive;
21133
21134    impl ::fidl_next::Method for Receive {
21135        const ORDINAL: u64 = 340832707723008660;
21136        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
21137            ::fidl_next::protocol::Flexibility::Flexible;
21138
21139        type Protocol = crate::Receiver;
21140
21141        type Request = crate::wire::ProtocolPayload;
21142
21143        type Response = ::fidl_next::util::Never;
21144    }
21145
21146    mod ___detail {
21147        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Receiver
21148        where
21149            ___T: ::fidl_next::Transport,
21150        {
21151            type Client = ReceiverClient<___T>;
21152            type Server = ReceiverServer<___T>;
21153        }
21154
21155        /// The client for the `Receiver` protocol.
21156        #[repr(transparent)]
21157        pub struct ReceiverClient<___T: ::fidl_next::Transport> {
21158            #[allow(dead_code)]
21159            client: ::fidl_next::protocol::Client<___T>,
21160        }
21161
21162        impl<___T> ReceiverClient<___T>
21163        where
21164            ___T: ::fidl_next::Transport,
21165        {
21166            #[doc = " Sends a channel to this receiver.\n"]
21167            pub fn receive(
21168                &self,
21169
21170                channel: impl ::fidl_next::Encode<
21171                    <___T as ::fidl_next::Transport>::SendBuffer,
21172                    Encoded = ::fidl_next::fuchsia::WireChannel,
21173                >,
21174            ) -> ::fidl_next::SendFuture<'_, ___T>
21175            where
21176                <___T as ::fidl_next::Transport>::SendBuffer:
21177                    ::fidl_next::encoder::InternalHandleEncoder,
21178                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
21179            {
21180                self.receive_with(crate::generic::ProtocolPayload { channel })
21181            }
21182
21183            #[doc = " Sends a channel to this receiver.\n"]
21184            pub fn receive_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
21185            where
21186                ___R: ::fidl_next::Encode<
21187                        <___T as ::fidl_next::Transport>::SendBuffer,
21188                        Encoded = crate::wire::ProtocolPayload,
21189                    >,
21190            {
21191                ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
21192                    340832707723008660,
21193                    <super::Receive as ::fidl_next::Method>::FLEXIBILITY,
21194                    request,
21195                ))
21196            }
21197        }
21198
21199        /// The server for the `Receiver` protocol.
21200        #[repr(transparent)]
21201        pub struct ReceiverServer<___T: ::fidl_next::Transport> {
21202            server: ::fidl_next::protocol::Server<___T>,
21203        }
21204
21205        impl<___T> ReceiverServer<___T> where ___T: ::fidl_next::Transport {}
21206    }
21207}
21208
21209/// A client handler for the Receiver protocol.
21210///
21211/// See [`Receiver`] for more details.
21212pub trait ReceiverClientHandler<
21213    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21214    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21215>
21216{
21217    fn on_unknown_interaction(
21218        &mut self,
21219        ordinal: u64,
21220    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21221        ::core::future::ready(())
21222    }
21223}
21224
21225impl<___T> ReceiverClientHandler<___T> for ::fidl_next::IgnoreEvents
21226where
21227    ___T: ::fidl_next::Transport,
21228{
21229    async fn on_unknown_interaction(&mut self, _: u64) {}
21230}
21231
21232impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Receiver
21233where
21234    ___H: ReceiverClientHandler<___T> + ::core::marker::Send,
21235    ___T: ::fidl_next::Transport,
21236{
21237    async fn on_event(
21238        handler: &mut ___H,
21239        ordinal: u64,
21240        flexibility: ::fidl_next::protocol::Flexibility,
21241        buffer: ___T::RecvBuffer,
21242    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
21243        match ordinal {
21244            ordinal => {
21245                handler.on_unknown_interaction(ordinal).await;
21246                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21247                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21248                } else {
21249                    Ok(())
21250                }
21251            }
21252        }
21253    }
21254}
21255
21256/// A server handler for the Receiver protocol.
21257///
21258/// See [`Receiver`] for more details.
21259pub trait ReceiverServerHandler<
21260    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
21261    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
21262>
21263{
21264    #[doc = " Sends a channel to this receiver.\n"]
21265    fn receive(
21266        &mut self,
21267
21268        request: ::fidl_next::Request<receiver::Receive, ___T>,
21269    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
21270
21271    fn on_unknown_interaction(
21272        &mut self,
21273        ordinal: u64,
21274    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
21275        ::core::future::ready(())
21276    }
21277}
21278
21279impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Receiver
21280where
21281    ___H: ReceiverServerHandler<___T> + ::core::marker::Send,
21282    ___T: ::fidl_next::Transport,
21283    <receiver::Receive as ::fidl_next::Method>::Request:
21284        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
21285{
21286    async fn on_one_way(
21287        handler: &mut ___H,
21288        ordinal: u64,
21289        flexibility: ::fidl_next::protocol::Flexibility,
21290        buffer: ___T::RecvBuffer,
21291    ) -> ::core::result::Result<
21292        (),
21293        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21294    > {
21295        match ordinal {
21296            340832707723008660 => match ::fidl_next::DecoderExt::decode(buffer) {
21297                Ok(decoded) => {
21298                    handler.receive(decoded).await;
21299                    Ok(())
21300                }
21301                Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
21302                    ordinal: 340832707723008660,
21303                    error,
21304                }),
21305            },
21306
21307            ordinal => {
21308                handler.on_unknown_interaction(ordinal).await;
21309                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21310                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21311                } else {
21312                    Ok(())
21313                }
21314            }
21315        }
21316    }
21317
21318    async fn on_two_way(
21319        handler: &mut ___H,
21320        ordinal: u64,
21321        flexibility: ::fidl_next::protocol::Flexibility,
21322        buffer: ___T::RecvBuffer,
21323        responder: ::fidl_next::protocol::Responder<___T>,
21324    ) -> ::core::result::Result<
21325        (),
21326        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
21327    > {
21328        match ordinal {
21329            ordinal => {
21330                handler.on_unknown_interaction(ordinal).await;
21331                if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
21332                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
21333                } else {
21334                    responder
21335                        .respond(
21336                            ordinal,
21337                            flexibility,
21338                            ::fidl_next::Flexible::<()>::FrameworkErr(
21339                                ::fidl_next::FrameworkError::UnknownMethod,
21340                            ),
21341                        )
21342                        .expect("encoding a framework error should never fail")
21343                        .await?;
21344                    Ok(())
21345                }
21346            }
21347        }
21348    }
21349}
21350
21351/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
21352pub mod compat {
21353
21354    impl ::fidl_next::CompatFrom<crate::Availability>
21355        for ::fidl_fuchsia_component_sandbox::Availability
21356    {
21357        fn compat_from(value: crate::Availability) -> Self {
21358            match value {
21359                crate::Availability::Required => Self::Required,
21360
21361                crate::Availability::Optional => Self::Optional,
21362
21363                crate::Availability::SameAsTarget => Self::SameAsTarget,
21364
21365                crate::Availability::Transitional => Self::Transitional,
21366            }
21367        }
21368    }
21369
21370    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Availability>
21371        for crate::Availability
21372    {
21373        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Availability) -> Self {
21374            match value {
21375                ::fidl_fuchsia_component_sandbox::Availability::Required => Self::Required,
21376
21377                ::fidl_fuchsia_component_sandbox::Availability::Optional => Self::Optional,
21378
21379                ::fidl_fuchsia_component_sandbox::Availability::SameAsTarget => Self::SameAsTarget,
21380
21381                ::fidl_fuchsia_component_sandbox::Availability::Transitional => Self::Transitional,
21382            }
21383        }
21384    }
21385
21386    impl ::fidl_next::CompatFrom<crate::Unit> for ::fidl_fuchsia_component_sandbox::Unit {
21387        #[inline]
21388        fn compat_from(value: crate::Unit) -> Self {
21389            Self {}
21390        }
21391    }
21392
21393    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unit> for crate::Unit {
21394        #[inline]
21395        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unit) -> Self {
21396            Self {}
21397        }
21398    }
21399
21400    impl ::fidl_next::CompatFrom<crate::Data> for ::fidl_fuchsia_component_sandbox::Data {
21401        fn compat_from(value: crate::Data) -> Self {
21402            match value {
21403                crate::Data::Bytes(value) => {
21404                    Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
21405                }
21406
21407                crate::Data::String(value) => {
21408                    Self::String(::fidl_next::CompatFrom::compat_from(value))
21409                }
21410
21411                crate::Data::Int64(value) => {
21412                    Self::Int64(::fidl_next::CompatFrom::compat_from(value))
21413                }
21414
21415                crate::Data::Uint64(value) => {
21416                    Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
21417                }
21418
21419                crate::Data::UnknownOrdinal_(unknown_ordinal) => {
21420                    Self::__SourceBreaking { unknown_ordinal }
21421                }
21422            }
21423        }
21424    }
21425
21426    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Data> for crate::Data {
21427        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Data) -> Self {
21428            match value {
21429                ::fidl_fuchsia_component_sandbox::Data::Bytes(value) => {
21430                    Self::Bytes(::fidl_next::CompatFrom::compat_from(value))
21431                }
21432
21433                ::fidl_fuchsia_component_sandbox::Data::String(value) => {
21434                    Self::String(::fidl_next::CompatFrom::compat_from(value))
21435                }
21436
21437                ::fidl_fuchsia_component_sandbox::Data::Int64(value) => {
21438                    Self::Int64(::fidl_next::CompatFrom::compat_from(value))
21439                }
21440
21441                ::fidl_fuchsia_component_sandbox::Data::Uint64(value) => {
21442                    Self::Uint64(::fidl_next::CompatFrom::compat_from(value))
21443                }
21444
21445                ::fidl_fuchsia_component_sandbox::Data::__SourceBreaking { unknown_ordinal } => {
21446                    Self::UnknownOrdinal_(unknown_ordinal)
21447                }
21448            }
21449        }
21450    }
21451
21452    impl ::fidl_next::CompatFrom<crate::DictionaryRef>
21453        for ::fidl_fuchsia_component_sandbox::DictionaryRef
21454    {
21455        #[inline]
21456        fn compat_from(value: crate::DictionaryRef) -> Self {
21457            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21458        }
21459    }
21460
21461    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRef>
21462        for crate::DictionaryRef
21463    {
21464        #[inline]
21465        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryRef) -> Self {
21466            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21467        }
21468    }
21469
21470    impl ::fidl_next::CompatFrom<crate::Connector> for ::fidl_fuchsia_component_sandbox::Connector {
21471        #[inline]
21472        fn compat_from(value: crate::Connector) -> Self {
21473            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21474        }
21475    }
21476
21477    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Connector> for crate::Connector {
21478        #[inline]
21479        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Connector) -> Self {
21480            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21481        }
21482    }
21483
21484    impl ::fidl_next::CompatFrom<crate::DirConnector>
21485        for ::fidl_fuchsia_component_sandbox::DirConnector
21486    {
21487        #[inline]
21488        fn compat_from(value: crate::DirConnector) -> Self {
21489            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21490        }
21491    }
21492
21493    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnector>
21494        for crate::DirConnector
21495    {
21496        #[inline]
21497        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirConnector) -> Self {
21498            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21499        }
21500    }
21501
21502    impl ::fidl_next::CompatFrom<crate::DirEntry> for ::fidl_fuchsia_component_sandbox::DirEntry {
21503        #[inline]
21504        fn compat_from(value: crate::DirEntry) -> Self {
21505            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21506        }
21507    }
21508
21509    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntry> for crate::DirEntry {
21510        #[inline]
21511        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirEntry) -> Self {
21512            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
21513        }
21514    }
21515
21516    impl ::fidl_next::CompatFrom<crate::Capability> for ::fidl_fuchsia_component_sandbox::Capability {
21517        fn compat_from(value: crate::Capability) -> Self {
21518            match value {
21519                crate::Capability::Unit(value) => {
21520                    Self::Unit(::fidl_next::CompatFrom::compat_from(value))
21521                }
21522
21523                crate::Capability::Handle(value) => {
21524                    Self::Handle(::fidl_next::CompatFrom::compat_from(value))
21525                }
21526
21527                crate::Capability::Data(value) => {
21528                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
21529                }
21530
21531                crate::Capability::Dictionary(value) => {
21532                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
21533                }
21534
21535                crate::Capability::Connector(value) => {
21536                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
21537                }
21538
21539                crate::Capability::DirConnector(value) => {
21540                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
21541                }
21542
21543                crate::Capability::Directory(value) => {
21544                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
21545                }
21546
21547                crate::Capability::DirEntry(value) => {
21548                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
21549                }
21550
21551                crate::Capability::ConnectorRouter(value) => {
21552                    Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21553                }
21554
21555                crate::Capability::DictionaryRouter(value) => {
21556                    Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
21557                }
21558
21559                crate::Capability::DirEntryRouter(value) => {
21560                    Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
21561                }
21562
21563                crate::Capability::DataRouter(value) => {
21564                    Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
21565                }
21566
21567                crate::Capability::DirConnectorRouter(value) => {
21568                    Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21569                }
21570
21571                crate::Capability::UnknownOrdinal_(unknown_ordinal) => {
21572                    Self::__SourceBreaking { unknown_ordinal }
21573                }
21574            }
21575        }
21576    }
21577
21578    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Capability> for crate::Capability {
21579        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Capability) -> Self {
21580            match value {
21581                ::fidl_fuchsia_component_sandbox::Capability::Unit(value) => {
21582                    Self::Unit(::fidl_next::CompatFrom::compat_from(value))
21583                }
21584
21585                ::fidl_fuchsia_component_sandbox::Capability::Handle(value) => {
21586                    Self::Handle(::fidl_next::CompatFrom::compat_from(value))
21587                }
21588
21589                ::fidl_fuchsia_component_sandbox::Capability::Data(value) => {
21590                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
21591                }
21592
21593                ::fidl_fuchsia_component_sandbox::Capability::Dictionary(value) => {
21594                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
21595                }
21596
21597                ::fidl_fuchsia_component_sandbox::Capability::Connector(value) => {
21598                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
21599                }
21600
21601                ::fidl_fuchsia_component_sandbox::Capability::DirConnector(value) => {
21602                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
21603                }
21604
21605                ::fidl_fuchsia_component_sandbox::Capability::Directory(value) => {
21606                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
21607                }
21608
21609                ::fidl_fuchsia_component_sandbox::Capability::DirEntry(value) => {
21610                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
21611                }
21612
21613                ::fidl_fuchsia_component_sandbox::Capability::ConnectorRouter(value) => {
21614                    Self::ConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21615                }
21616
21617                ::fidl_fuchsia_component_sandbox::Capability::DictionaryRouter(value) => {
21618                    Self::DictionaryRouter(::fidl_next::CompatFrom::compat_from(value))
21619                }
21620
21621                ::fidl_fuchsia_component_sandbox::Capability::DirEntryRouter(value) => {
21622                    Self::DirEntryRouter(::fidl_next::CompatFrom::compat_from(value))
21623                }
21624
21625                ::fidl_fuchsia_component_sandbox::Capability::DataRouter(value) => {
21626                    Self::DataRouter(::fidl_next::CompatFrom::compat_from(value))
21627                }
21628
21629                ::fidl_fuchsia_component_sandbox::Capability::DirConnectorRouter(value) => {
21630                    Self::DirConnectorRouter(::fidl_next::CompatFrom::compat_from(value))
21631                }
21632
21633                ::fidl_fuchsia_component_sandbox::Capability::__SourceBreaking {
21634                    unknown_ordinal,
21635                } => Self::UnknownOrdinal_(unknown_ordinal),
21636            }
21637        }
21638    }
21639
21640    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDuplicateRequest>
21641        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest
21642    {
21643        #[inline]
21644        fn compat_from(value: crate::CapabilityStoreDuplicateRequest) -> Self {
21645            Self {
21646                id: ::fidl_next::CompatFrom::compat_from(value.id),
21647
21648                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21649            }
21650        }
21651    }
21652
21653    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest>
21654        for crate::CapabilityStoreDuplicateRequest
21655    {
21656        #[inline]
21657        fn compat_from(
21658            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDuplicateRequest,
21659        ) -> Self {
21660            Self {
21661                id: ::fidl_next::CompatFrom::compat_from(value.id),
21662
21663                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21664            }
21665        }
21666    }
21667
21668    impl ::fidl_next::CompatFrom<crate::CapabilityStoreError>
21669        for ::fidl_fuchsia_component_sandbox::CapabilityStoreError
21670    {
21671        fn compat_from(value: crate::CapabilityStoreError) -> Self {
21672            match value {
21673                crate::CapabilityStoreError::IdNotFound => Self::IdNotFound,
21674
21675                crate::CapabilityStoreError::IdAlreadyExists => Self::IdAlreadyExists,
21676
21677                crate::CapabilityStoreError::BadCapability => Self::BadCapability,
21678
21679                crate::CapabilityStoreError::WrongType => Self::WrongType,
21680
21681                crate::CapabilityStoreError::NotDuplicatable => Self::NotDuplicatable,
21682
21683                crate::CapabilityStoreError::ItemNotFound => Self::ItemNotFound,
21684
21685                crate::CapabilityStoreError::ItemAlreadyExists => Self::ItemAlreadyExists,
21686
21687                crate::CapabilityStoreError::InvalidKey => Self::InvalidKey,
21688
21689                crate::CapabilityStoreError::InvalidArgs => Self::InvalidArgs,
21690
21691                crate::CapabilityStoreError::UnknownOrdinal_(unknown_ordinal) => {
21692                    Self::__SourceBreaking { unknown_ordinal }
21693                }
21694            }
21695        }
21696    }
21697
21698    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreError>
21699        for crate::CapabilityStoreError
21700    {
21701        fn compat_from(value: ::fidl_fuchsia_component_sandbox::CapabilityStoreError) -> Self {
21702            match value {
21703                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdNotFound => {
21704                    Self::IdNotFound
21705                }
21706
21707                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::IdAlreadyExists => {
21708                    Self::IdAlreadyExists
21709                }
21710
21711                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::BadCapability => {
21712                    Self::BadCapability
21713                }
21714
21715                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::WrongType => {
21716                    Self::WrongType
21717                }
21718
21719                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::NotDuplicatable => {
21720                    Self::NotDuplicatable
21721                }
21722
21723                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemNotFound => {
21724                    Self::ItemNotFound
21725                }
21726
21727                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::ItemAlreadyExists => {
21728                    Self::ItemAlreadyExists
21729                }
21730
21731                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidKey => {
21732                    Self::InvalidKey
21733                }
21734
21735                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::InvalidArgs => {
21736                    Self::InvalidArgs
21737                }
21738
21739                ::fidl_fuchsia_component_sandbox::CapabilityStoreError::__SourceBreaking {
21740                    unknown_ordinal: value,
21741                } => Self::UnknownOrdinal_(value),
21742            }
21743        }
21744    }
21745
21746    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDropRequest>
21747        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest
21748    {
21749        #[inline]
21750        fn compat_from(value: crate::CapabilityStoreDropRequest) -> Self {
21751            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21752        }
21753    }
21754
21755    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest>
21756        for crate::CapabilityStoreDropRequest
21757    {
21758        #[inline]
21759        fn compat_from(
21760            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDropRequest,
21761        ) -> Self {
21762            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21763        }
21764    }
21765
21766    impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportRequest>
21767        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest
21768    {
21769        #[inline]
21770        fn compat_from(value: crate::CapabilityStoreExportRequest) -> Self {
21771            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21772        }
21773    }
21774
21775    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest>
21776        for crate::CapabilityStoreExportRequest
21777    {
21778        #[inline]
21779        fn compat_from(
21780            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportRequest,
21781        ) -> Self {
21782            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21783        }
21784    }
21785
21786    impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorCreateRequest>
21787        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest
21788    {
21789        #[inline]
21790        fn compat_from(value: crate::CapabilityStoreConnectorCreateRequest) -> Self {
21791            Self {
21792                id: ::fidl_next::CompatFrom::compat_from(value.id),
21793
21794                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
21795            }
21796        }
21797    }
21798
21799    impl
21800        ::fidl_next::CompatFrom<
21801            ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
21802        > for crate::CapabilityStoreConnectorCreateRequest
21803    {
21804        #[inline]
21805        fn compat_from(
21806            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorCreateRequest,
21807        ) -> Self {
21808            Self {
21809                id: ::fidl_next::CompatFrom::compat_from(value.id),
21810
21811                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
21812            }
21813        }
21814    }
21815
21816    impl ::fidl_next::CompatFrom<crate::CapabilityStoreConnectorOpenRequest>
21817        for ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest
21818    {
21819        #[inline]
21820        fn compat_from(value: crate::CapabilityStoreConnectorOpenRequest) -> Self {
21821            Self {
21822                id: ::fidl_next::CompatFrom::compat_from(value.id),
21823
21824                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21825            }
21826        }
21827    }
21828
21829    impl
21830        ::fidl_next::CompatFrom<
21831            ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
21832        > for crate::CapabilityStoreConnectorOpenRequest
21833    {
21834        #[inline]
21835        fn compat_from(
21836            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreConnectorOpenRequest,
21837        ) -> Self {
21838            Self {
21839                id: ::fidl_next::CompatFrom::compat_from(value.id),
21840
21841                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21842            }
21843        }
21844    }
21845
21846    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCreateRequest>
21847        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest
21848    {
21849        #[inline]
21850        fn compat_from(value: crate::CapabilityStoreDictionaryCreateRequest) -> Self {
21851            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21852        }
21853    }
21854
21855    impl
21856        ::fidl_next::CompatFrom<
21857            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
21858        > for crate::CapabilityStoreDictionaryCreateRequest
21859    {
21860        #[inline]
21861        fn compat_from(
21862            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCreateRequest,
21863        ) -> Self {
21864            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
21865        }
21866    }
21867
21868    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyImportRequest>
21869        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest
21870    {
21871        #[inline]
21872        fn compat_from(value: crate::CapabilityStoreDictionaryLegacyImportRequest) -> Self {
21873            Self {
21874                id: ::fidl_next::CompatFrom::compat_from(value.id),
21875
21876                client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
21877            }
21878        }
21879    }
21880
21881    impl
21882        ::fidl_next::CompatFrom<
21883            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
21884        > for crate::CapabilityStoreDictionaryLegacyImportRequest
21885    {
21886        #[inline]
21887        fn compat_from(
21888            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyImportRequest,
21889        ) -> Self {
21890            Self {
21891                id: ::fidl_next::CompatFrom::compat_from(value.id),
21892
21893                client_end: ::fidl_next::CompatFrom::compat_from(value.client_end),
21894            }
21895        }
21896    }
21897
21898    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryLegacyExportRequest>
21899        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest
21900    {
21901        #[inline]
21902        fn compat_from(value: crate::CapabilityStoreDictionaryLegacyExportRequest) -> Self {
21903            Self {
21904                id: ::fidl_next::CompatFrom::compat_from(value.id),
21905
21906                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21907            }
21908        }
21909    }
21910
21911    impl
21912        ::fidl_next::CompatFrom<
21913            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
21914        > for crate::CapabilityStoreDictionaryLegacyExportRequest
21915    {
21916        #[inline]
21917        fn compat_from(
21918            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryLegacyExportRequest,
21919        ) -> Self {
21920            Self {
21921                id: ::fidl_next::CompatFrom::compat_from(value.id),
21922
21923                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
21924            }
21925        }
21926    }
21927
21928    impl ::fidl_next::CompatFrom<crate::DictionaryItem>
21929        for ::fidl_fuchsia_component_sandbox::DictionaryItem
21930    {
21931        #[inline]
21932        fn compat_from(value: crate::DictionaryItem) -> Self {
21933            Self {
21934                key: ::fidl_next::CompatFrom::compat_from(value.key),
21935
21936                value: ::fidl_next::CompatFrom::compat_from(value.value),
21937            }
21938        }
21939    }
21940
21941    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryItem>
21942        for crate::DictionaryItem
21943    {
21944        #[inline]
21945        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryItem) -> Self {
21946            Self {
21947                key: ::fidl_next::CompatFrom::compat_from(value.key),
21948
21949                value: ::fidl_next::CompatFrom::compat_from(value.value),
21950            }
21951        }
21952    }
21953
21954    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryInsertRequest>
21955        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest
21956    {
21957        #[inline]
21958        fn compat_from(value: crate::CapabilityStoreDictionaryInsertRequest) -> Self {
21959            Self {
21960                id: ::fidl_next::CompatFrom::compat_from(value.id),
21961
21962                item: ::fidl_next::CompatFrom::compat_from(value.item),
21963            }
21964        }
21965    }
21966
21967    impl
21968        ::fidl_next::CompatFrom<
21969            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
21970        > for crate::CapabilityStoreDictionaryInsertRequest
21971    {
21972        #[inline]
21973        fn compat_from(
21974            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryInsertRequest,
21975        ) -> Self {
21976            Self {
21977                id: ::fidl_next::CompatFrom::compat_from(value.id),
21978
21979                item: ::fidl_next::CompatFrom::compat_from(value.item),
21980            }
21981        }
21982    }
21983
21984    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryGetRequest>
21985        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest
21986    {
21987        #[inline]
21988        fn compat_from(value: crate::CapabilityStoreDictionaryGetRequest) -> Self {
21989            Self {
21990                id: ::fidl_next::CompatFrom::compat_from(value.id),
21991
21992                key: ::fidl_next::CompatFrom::compat_from(value.key),
21993
21994                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
21995            }
21996        }
21997    }
21998
21999    impl
22000        ::fidl_next::CompatFrom<
22001            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
22002        > for crate::CapabilityStoreDictionaryGetRequest
22003    {
22004        #[inline]
22005        fn compat_from(
22006            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryGetRequest,
22007        ) -> Self {
22008            Self {
22009                id: ::fidl_next::CompatFrom::compat_from(value.id),
22010
22011                key: ::fidl_next::CompatFrom::compat_from(value.key),
22012
22013                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22014            }
22015        }
22016    }
22017
22018    impl ::fidl_next::CompatFrom<crate::WrappedCapabilityId>
22019        for ::fidl_fuchsia_component_sandbox::WrappedCapabilityId
22020    {
22021        #[inline]
22022        fn compat_from(value: crate::WrappedCapabilityId) -> Self {
22023            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
22024        }
22025    }
22026
22027    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::WrappedCapabilityId>
22028        for crate::WrappedCapabilityId
22029    {
22030        #[inline]
22031        fn compat_from(value: ::fidl_fuchsia_component_sandbox::WrappedCapabilityId) -> Self {
22032            Self { id: ::fidl_next::CompatFrom::compat_from(value.id) }
22033        }
22034    }
22035
22036    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryRemoveRequest>
22037        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest
22038    {
22039        #[inline]
22040        fn compat_from(value: crate::CapabilityStoreDictionaryRemoveRequest) -> Self {
22041            Self {
22042                id: ::fidl_next::CompatFrom::compat_from(value.id),
22043
22044                key: ::fidl_next::CompatFrom::compat_from(value.key),
22045
22046                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22047            }
22048        }
22049    }
22050
22051    impl
22052        ::fidl_next::CompatFrom<
22053            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
22054        > for crate::CapabilityStoreDictionaryRemoveRequest
22055    {
22056        #[inline]
22057        fn compat_from(
22058            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryRemoveRequest,
22059        ) -> Self {
22060            Self {
22061                id: ::fidl_next::CompatFrom::compat_from(value.id),
22062
22063                key: ::fidl_next::CompatFrom::compat_from(value.key),
22064
22065                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22066            }
22067        }
22068    }
22069
22070    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryCopyRequest>
22071        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest
22072    {
22073        #[inline]
22074        fn compat_from(value: crate::CapabilityStoreDictionaryCopyRequest) -> Self {
22075            Self {
22076                id: ::fidl_next::CompatFrom::compat_from(value.id),
22077
22078                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22079            }
22080        }
22081    }
22082
22083    impl
22084        ::fidl_next::CompatFrom<
22085            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
22086        > for crate::CapabilityStoreDictionaryCopyRequest
22087    {
22088        #[inline]
22089        fn compat_from(
22090            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryCopyRequest,
22091        ) -> Self {
22092            Self {
22093                id: ::fidl_next::CompatFrom::compat_from(value.id),
22094
22095                dest_id: ::fidl_next::CompatFrom::compat_from(value.dest_id),
22096            }
22097        }
22098    }
22099
22100    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryKeysRequest>
22101        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest
22102    {
22103        #[inline]
22104        fn compat_from(value: crate::CapabilityStoreDictionaryKeysRequest) -> Self {
22105            Self {
22106                id: ::fidl_next::CompatFrom::compat_from(value.id),
22107
22108                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22109            }
22110        }
22111    }
22112
22113    impl
22114        ::fidl_next::CompatFrom<
22115            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
22116        > for crate::CapabilityStoreDictionaryKeysRequest
22117    {
22118        #[inline]
22119        fn compat_from(
22120            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryKeysRequest,
22121        ) -> Self {
22122            Self {
22123                id: ::fidl_next::CompatFrom::compat_from(value.id),
22124
22125                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22126            }
22127        }
22128    }
22129
22130    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryEnumerateRequest>
22131        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest
22132    {
22133        #[inline]
22134        fn compat_from(value: crate::CapabilityStoreDictionaryEnumerateRequest) -> Self {
22135            Self {
22136                id: ::fidl_next::CompatFrom::compat_from(value.id),
22137
22138                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22139            }
22140        }
22141    }
22142
22143    impl
22144        ::fidl_next::CompatFrom<
22145            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
22146        > for crate::CapabilityStoreDictionaryEnumerateRequest
22147    {
22148        #[inline]
22149        fn compat_from(
22150            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryEnumerateRequest,
22151        ) -> Self {
22152            Self {
22153                id: ::fidl_next::CompatFrom::compat_from(value.id),
22154
22155                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22156            }
22157        }
22158    }
22159
22160    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDictionaryDrainRequest>
22161        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest
22162    {
22163        #[inline]
22164        fn compat_from(value: crate::CapabilityStoreDictionaryDrainRequest) -> Self {
22165            Self {
22166                id: ::fidl_next::CompatFrom::compat_from(value.id),
22167
22168                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22169            }
22170        }
22171    }
22172
22173    impl
22174        ::fidl_next::CompatFrom<
22175            ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
22176        > for crate::CapabilityStoreDictionaryDrainRequest
22177    {
22178        #[inline]
22179        fn compat_from(
22180            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDictionaryDrainRequest,
22181        ) -> Self {
22182            Self {
22183                id: ::fidl_next::CompatFrom::compat_from(value.id),
22184
22185                iterator: ::fidl_next::CompatFrom::compat_from(value.iterator),
22186            }
22187        }
22188    }
22189
22190    impl ::fidl_next::CompatFrom<crate::CapabilityStoreExportResponse>
22191        for ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse
22192    {
22193        #[inline]
22194        fn compat_from(value: crate::CapabilityStoreExportResponse) -> Self {
22195            Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
22196        }
22197    }
22198
22199    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse>
22200        for crate::CapabilityStoreExportResponse
22201    {
22202        #[inline]
22203        fn compat_from(
22204            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreExportResponse,
22205        ) -> Self {
22206            Self { capability: ::fidl_next::CompatFrom::compat_from(value.capability) }
22207        }
22208    }
22209
22210    impl ::fidl_next::CompatFrom<crate::CapabilityStoreImportRequest>
22211        for ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest
22212    {
22213        #[inline]
22214        fn compat_from(value: crate::CapabilityStoreImportRequest) -> Self {
22215            Self {
22216                id: ::fidl_next::CompatFrom::compat_from(value.id),
22217
22218                capability: ::fidl_next::CompatFrom::compat_from(value.capability),
22219            }
22220        }
22221    }
22222
22223    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest>
22224        for crate::CapabilityStoreImportRequest
22225    {
22226        #[inline]
22227        fn compat_from(
22228            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreImportRequest,
22229        ) -> Self {
22230            Self {
22231                id: ::fidl_next::CompatFrom::compat_from(value.id),
22232
22233                capability: ::fidl_next::CompatFrom::compat_from(value.capability),
22234            }
22235        }
22236    }
22237
22238    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorCreateRequest>
22239        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest
22240    {
22241        #[inline]
22242        fn compat_from(value: crate::CapabilityStoreDirConnectorCreateRequest) -> Self {
22243            Self {
22244                id: ::fidl_next::CompatFrom::compat_from(value.id),
22245
22246                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
22247            }
22248        }
22249    }
22250
22251    impl
22252        ::fidl_next::CompatFrom<
22253            ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
22254        > for crate::CapabilityStoreDirConnectorCreateRequest
22255    {
22256        #[inline]
22257        fn compat_from(
22258            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorCreateRequest,
22259        ) -> Self {
22260            Self {
22261                id: ::fidl_next::CompatFrom::compat_from(value.id),
22262
22263                receiver: ::fidl_next::CompatFrom::compat_from(value.receiver),
22264            }
22265        }
22266    }
22267
22268    impl ::fidl_next::CompatFrom<crate::CapabilityStoreDirConnectorOpenRequest>
22269        for ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest
22270    {
22271        #[inline]
22272        fn compat_from(value: crate::CapabilityStoreDirConnectorOpenRequest) -> Self {
22273            Self {
22274                id: ::fidl_next::CompatFrom::compat_from(value.id),
22275
22276                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
22277            }
22278        }
22279    }
22280
22281    impl
22282        ::fidl_next::CompatFrom<
22283            ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
22284        > for crate::CapabilityStoreDirConnectorOpenRequest
22285    {
22286        #[inline]
22287        fn compat_from(
22288            value: ::fidl_fuchsia_component_sandbox::CapabilityStoreDirConnectorOpenRequest,
22289        ) -> Self {
22290            Self {
22291                id: ::fidl_next::CompatFrom::compat_from(value.id),
22292
22293                server_end: ::fidl_next::CompatFrom::compat_from(value.server_end),
22294            }
22295        }
22296    }
22297
22298    #[cfg(target_os = "fuchsia")]
22299    /// An alias for a client over `zx::Channel` for the `CapabilityStore`
22300    /// protocol.
22301    pub type CapabilityStoreProxy = ::fidl_next::Client<crate::CapabilityStore>;
22302
22303    impl ::fidl_next::CompatFrom<crate::CapabilityStore>
22304        for ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker
22305    {
22306        fn compat_from(_: crate::CapabilityStore) -> Self {
22307            Self
22308        }
22309    }
22310
22311    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreMarker>
22312        for crate::CapabilityStore
22313    {
22314        fn compat_from(_: ::fidl_fuchsia_component_sandbox::CapabilityStoreMarker) -> Self {
22315            Self
22316        }
22317    }
22318
22319    #[cfg(target_os = "fuchsia")]
22320
22321    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::CapabilityStoreProxy>
22322        for crate::CapabilityStore
22323    {
22324        fn client_compat_from(
22325            proxy: ::fidl_fuchsia_component_sandbox::CapabilityStoreProxy,
22326        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22327            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22328            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22329            ::fidl_next::ClientDispatcher::new(client_end)
22330        }
22331    }
22332
22333    impl ::fidl_next::CompatFrom<crate::InstanceToken>
22334        for ::fidl_fuchsia_component_sandbox::InstanceToken
22335    {
22336        #[inline]
22337        fn compat_from(value: crate::InstanceToken) -> Self {
22338            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
22339        }
22340    }
22341
22342    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::InstanceToken>
22343        for crate::InstanceToken
22344    {
22345        #[inline]
22346        fn compat_from(value: ::fidl_fuchsia_component_sandbox::InstanceToken) -> Self {
22347            Self { token: ::fidl_next::CompatFrom::compat_from(value.token) }
22348        }
22349    }
22350
22351    impl ::fidl_next::CompatFrom<crate::RouteRequest>
22352        for ::fidl_fuchsia_component_sandbox::RouteRequest
22353    {
22354        fn compat_from(value: crate::RouteRequest) -> Self {
22355            Self {
22356                requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
22357
22358                metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
22359
22360                __source_breaking: ::fidl::marker::SourceBreaking,
22361            }
22362        }
22363    }
22364
22365    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouteRequest>
22366        for crate::RouteRequest
22367    {
22368        fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouteRequest) -> Self {
22369            Self {
22370                requesting: ::fidl_next::CompatFrom::compat_from(value.requesting),
22371
22372                metadata: ::fidl_next::CompatFrom::compat_from(value.metadata),
22373            }
22374        }
22375    }
22376
22377    impl ::fidl_next::CompatFrom<crate::ConnectorRouterRouteResponse>
22378        for ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse
22379    {
22380        fn compat_from(value: crate::ConnectorRouterRouteResponse) -> Self {
22381            match value {
22382                crate::ConnectorRouterRouteResponse::Connector(value) => {
22383                    Self::Connector(::fidl_next::CompatFrom::compat_from(value))
22384                }
22385
22386                crate::ConnectorRouterRouteResponse::Unavailable(value) => {
22387                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22388                }
22389            }
22390        }
22391    }
22392
22393    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse>
22394        for crate::ConnectorRouterRouteResponse
22395    {
22396        fn compat_from(
22397            value: ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse,
22398        ) -> Self {
22399            match value {
22400                ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Connector(
22401                    value,
22402                ) => Self::Connector(::fidl_next::CompatFrom::compat_from(value)),
22403
22404                ::fidl_fuchsia_component_sandbox::ConnectorRouterRouteResponse::Unavailable(
22405                    value,
22406                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
22407            }
22408        }
22409    }
22410
22411    impl ::fidl_next::CompatFrom<crate::RouterError> for ::fidl_fuchsia_component_sandbox::RouterError {
22412        fn compat_from(value: crate::RouterError) -> Self {
22413            match value {
22414                crate::RouterError::NotFound => Self::NotFound,
22415
22416                crate::RouterError::InvalidArgs => Self::InvalidArgs,
22417
22418                crate::RouterError::NotSupported => Self::NotSupported,
22419
22420                crate::RouterError::Internal => Self::Internal,
22421
22422                crate::RouterError::UnknownOrdinal_(unknown_ordinal) => {
22423                    Self::__SourceBreaking { unknown_ordinal }
22424                }
22425            }
22426        }
22427    }
22428
22429    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::RouterError> for crate::RouterError {
22430        fn compat_from(value: ::fidl_fuchsia_component_sandbox::RouterError) -> Self {
22431            match value {
22432                ::fidl_fuchsia_component_sandbox::RouterError::NotFound => Self::NotFound,
22433
22434                ::fidl_fuchsia_component_sandbox::RouterError::InvalidArgs => Self::InvalidArgs,
22435
22436                ::fidl_fuchsia_component_sandbox::RouterError::NotSupported => Self::NotSupported,
22437
22438                ::fidl_fuchsia_component_sandbox::RouterError::Internal => Self::Internal,
22439
22440                ::fidl_fuchsia_component_sandbox::RouterError::__SourceBreaking {
22441                    unknown_ordinal: value,
22442                } => Self::UnknownOrdinal_(value),
22443            }
22444        }
22445    }
22446
22447    #[cfg(target_os = "fuchsia")]
22448    /// An alias for a client over `zx::Channel` for the `ConnectorRouter`
22449    /// protocol.
22450    pub type ConnectorRouterProxy = ::fidl_next::Client<crate::ConnectorRouter>;
22451
22452    impl ::fidl_next::CompatFrom<crate::ConnectorRouter>
22453        for ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker
22454    {
22455        fn compat_from(_: crate::ConnectorRouter) -> Self {
22456            Self
22457        }
22458    }
22459
22460    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterMarker>
22461        for crate::ConnectorRouter
22462    {
22463        fn compat_from(_: ::fidl_fuchsia_component_sandbox::ConnectorRouterMarker) -> Self {
22464            Self
22465        }
22466    }
22467
22468    #[cfg(target_os = "fuchsia")]
22469
22470    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ConnectorRouterProxy>
22471        for crate::ConnectorRouter
22472    {
22473        fn client_compat_from(
22474            proxy: ::fidl_fuchsia_component_sandbox::ConnectorRouterProxy,
22475        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22476            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22477            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22478            ::fidl_next::ClientDispatcher::new(client_end)
22479        }
22480    }
22481
22482    impl ::fidl_next::CompatFrom<crate::DataRouterRouteResponse>
22483        for ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse
22484    {
22485        fn compat_from(value: crate::DataRouterRouteResponse) -> Self {
22486            match value {
22487                crate::DataRouterRouteResponse::Data(value) => {
22488                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
22489                }
22490
22491                crate::DataRouterRouteResponse::Unavailable(value) => {
22492                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22493                }
22494            }
22495        }
22496    }
22497
22498    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterRouteResponse>
22499        for crate::DataRouterRouteResponse
22500    {
22501        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse) -> Self {
22502            match value {
22503                ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Data(value) => {
22504                    Self::Data(::fidl_next::CompatFrom::compat_from(value))
22505                }
22506
22507                ::fidl_fuchsia_component_sandbox::DataRouterRouteResponse::Unavailable(value) => {
22508                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22509                }
22510            }
22511        }
22512    }
22513
22514    #[cfg(target_os = "fuchsia")]
22515    /// An alias for a client over `zx::Channel` for the `DataRouter`
22516    /// protocol.
22517    pub type DataRouterProxy = ::fidl_next::Client<crate::DataRouter>;
22518
22519    impl ::fidl_next::CompatFrom<crate::DataRouter>
22520        for ::fidl_fuchsia_component_sandbox::DataRouterMarker
22521    {
22522        fn compat_from(_: crate::DataRouter) -> Self {
22523            Self
22524        }
22525    }
22526
22527    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DataRouterMarker>
22528        for crate::DataRouter
22529    {
22530        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DataRouterMarker) -> Self {
22531            Self
22532        }
22533    }
22534
22535    #[cfg(target_os = "fuchsia")]
22536
22537    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DataRouterProxy>
22538        for crate::DataRouter
22539    {
22540        fn client_compat_from(
22541            proxy: ::fidl_fuchsia_component_sandbox::DataRouterProxy,
22542        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22543            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22544            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22545            ::fidl_next::ClientDispatcher::new(client_end)
22546        }
22547    }
22548
22549    #[cfg(target_os = "fuchsia")]
22550    /// An alias for a client over `zx::Channel` for the `Dictionary`
22551    /// protocol.
22552    pub type DictionaryProxy = ::fidl_next::Client<crate::Dictionary>;
22553
22554    impl ::fidl_next::CompatFrom<crate::Dictionary>
22555        for ::fidl_fuchsia_component_sandbox::DictionaryMarker
22556    {
22557        fn compat_from(_: crate::Dictionary) -> Self {
22558            Self
22559        }
22560    }
22561
22562    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryMarker>
22563        for crate::Dictionary
22564    {
22565        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryMarker) -> Self {
22566            Self
22567        }
22568    }
22569
22570    #[cfg(target_os = "fuchsia")]
22571
22572    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryProxy>
22573        for crate::Dictionary
22574    {
22575        fn client_compat_from(
22576            proxy: ::fidl_fuchsia_component_sandbox::DictionaryProxy,
22577        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22578            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22579            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22580            ::fidl_next::ClientDispatcher::new(client_end)
22581        }
22582    }
22583
22584    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextRequest>
22585        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest
22586    {
22587        #[inline]
22588        fn compat_from(value: crate::DictionaryDrainIteratorGetNextRequest) -> Self {
22589            Self {
22590                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22591
22592                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22593            }
22594        }
22595    }
22596
22597    impl
22598        ::fidl_next::CompatFrom<
22599            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
22600        > for crate::DictionaryDrainIteratorGetNextRequest
22601    {
22602        #[inline]
22603        fn compat_from(
22604            value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextRequest,
22605        ) -> Self {
22606            Self {
22607                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22608
22609                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22610            }
22611        }
22612    }
22613
22614    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIteratorGetNextResponse>
22615        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse
22616    {
22617        #[inline]
22618        fn compat_from(value: crate::DictionaryDrainIteratorGetNextResponse) -> Self {
22619            Self {
22620                items: ::fidl_next::CompatFrom::compat_from(value.items),
22621
22622                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22623            }
22624        }
22625    }
22626
22627    impl
22628        ::fidl_next::CompatFrom<
22629            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
22630        > for crate::DictionaryDrainIteratorGetNextResponse
22631    {
22632        #[inline]
22633        fn compat_from(
22634            value: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorGetNextResponse,
22635        ) -> Self {
22636            Self {
22637                items: ::fidl_next::CompatFrom::compat_from(value.items),
22638
22639                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22640            }
22641        }
22642    }
22643
22644    #[cfg(target_os = "fuchsia")]
22645    /// An alias for a client over `zx::Channel` for the `DictionaryDrainIterator`
22646    /// protocol.
22647    pub type DictionaryDrainIteratorProxy = ::fidl_next::Client<crate::DictionaryDrainIterator>;
22648
22649    impl ::fidl_next::CompatFrom<crate::DictionaryDrainIterator>
22650        for ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker
22651    {
22652        fn compat_from(_: crate::DictionaryDrainIterator) -> Self {
22653            Self
22654        }
22655    }
22656
22657    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker>
22658        for crate::DictionaryDrainIterator
22659    {
22660        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorMarker) -> Self {
22661            Self
22662        }
22663    }
22664
22665    #[cfg(target_os = "fuchsia")]
22666
22667    impl
22668        ::fidl_next::ClientCompatFrom<
22669            ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
22670        > for crate::DictionaryDrainIterator
22671    {
22672        fn client_compat_from(
22673            proxy: ::fidl_fuchsia_component_sandbox::DictionaryDrainIteratorProxy,
22674        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22675            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22676            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22677            ::fidl_next::ClientDispatcher::new(client_end)
22678        }
22679    }
22680
22681    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextRequest>
22682        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest
22683    {
22684        #[inline]
22685        fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextRequest) -> Self {
22686            Self {
22687                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22688
22689                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22690            }
22691        }
22692    }
22693
22694    impl
22695        ::fidl_next::CompatFrom<
22696            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
22697        > for crate::DictionaryEnumerateIteratorGetNextRequest
22698    {
22699        #[inline]
22700        fn compat_from(
22701            value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextRequest,
22702        ) -> Self {
22703            Self {
22704                start_id: ::fidl_next::CompatFrom::compat_from(value.start_id),
22705
22706                limit: ::fidl_next::CompatFrom::compat_from(value.limit),
22707            }
22708        }
22709    }
22710
22711    impl ::fidl_next::CompatFrom<crate::DictionaryOptionalItem>
22712        for ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem
22713    {
22714        #[inline]
22715        fn compat_from(value: crate::DictionaryOptionalItem) -> Self {
22716            Self {
22717                key: ::fidl_next::CompatFrom::compat_from(value.key),
22718
22719                value: ::fidl_next::CompatFrom::compat_from(value.value),
22720            }
22721        }
22722    }
22723
22724    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryOptionalItem>
22725        for crate::DictionaryOptionalItem
22726    {
22727        #[inline]
22728        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryOptionalItem) -> Self {
22729            Self {
22730                key: ::fidl_next::CompatFrom::compat_from(value.key),
22731
22732                value: ::fidl_next::CompatFrom::compat_from(value.value),
22733            }
22734        }
22735    }
22736
22737    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIteratorGetNextResponse>
22738        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse
22739    {
22740        #[inline]
22741        fn compat_from(value: crate::DictionaryEnumerateIteratorGetNextResponse) -> Self {
22742            Self {
22743                items: ::fidl_next::CompatFrom::compat_from(value.items),
22744
22745                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22746            }
22747        }
22748    }
22749
22750    impl
22751        ::fidl_next::CompatFrom<
22752            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
22753        > for crate::DictionaryEnumerateIteratorGetNextResponse
22754    {
22755        #[inline]
22756        fn compat_from(
22757            value: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorGetNextResponse,
22758        ) -> Self {
22759            Self {
22760                items: ::fidl_next::CompatFrom::compat_from(value.items),
22761
22762                end_id: ::fidl_next::CompatFrom::compat_from(value.end_id),
22763            }
22764        }
22765    }
22766
22767    #[cfg(target_os = "fuchsia")]
22768    /// An alias for a client over `zx::Channel` for the `DictionaryEnumerateIterator`
22769    /// protocol.
22770    pub type DictionaryEnumerateIteratorProxy =
22771        ::fidl_next::Client<crate::DictionaryEnumerateIterator>;
22772
22773    impl ::fidl_next::CompatFrom<crate::DictionaryEnumerateIterator>
22774        for ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker
22775    {
22776        fn compat_from(_: crate::DictionaryEnumerateIterator) -> Self {
22777            Self
22778        }
22779    }
22780
22781    impl
22782        ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker>
22783        for crate::DictionaryEnumerateIterator
22784    {
22785        fn compat_from(
22786            _: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorMarker,
22787        ) -> Self {
22788            Self
22789        }
22790    }
22791
22792    #[cfg(target_os = "fuchsia")]
22793
22794    impl
22795        ::fidl_next::ClientCompatFrom<
22796            ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
22797        > for crate::DictionaryEnumerateIterator
22798    {
22799        fn client_compat_from(
22800            proxy: ::fidl_fuchsia_component_sandbox::DictionaryEnumerateIteratorProxy,
22801        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22802            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22803            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22804            ::fidl_next::ClientDispatcher::new(client_end)
22805        }
22806    }
22807
22808    impl ::fidl_next::CompatFrom<crate::DictionaryError>
22809        for ::fidl_fuchsia_component_sandbox::DictionaryError
22810    {
22811        fn compat_from(value: crate::DictionaryError) -> Self {
22812            match value {
22813                crate::DictionaryError::NotFound => Self::NotFound,
22814
22815                crate::DictionaryError::AlreadyExists => Self::AlreadyExists,
22816
22817                crate::DictionaryError::BadCapability => Self::BadCapability,
22818
22819                crate::DictionaryError::InvalidKey => Self::InvalidKey,
22820
22821                crate::DictionaryError::NotCloneable => Self::NotCloneable,
22822
22823                crate::DictionaryError::UnknownOrdinal_(unknown_ordinal) => {
22824                    Self::__SourceBreaking { unknown_ordinal }
22825                }
22826            }
22827        }
22828    }
22829
22830    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryError>
22831        for crate::DictionaryError
22832    {
22833        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DictionaryError) -> Self {
22834            match value {
22835                ::fidl_fuchsia_component_sandbox::DictionaryError::NotFound => Self::NotFound,
22836
22837                ::fidl_fuchsia_component_sandbox::DictionaryError::AlreadyExists => {
22838                    Self::AlreadyExists
22839                }
22840
22841                ::fidl_fuchsia_component_sandbox::DictionaryError::BadCapability => {
22842                    Self::BadCapability
22843                }
22844
22845                ::fidl_fuchsia_component_sandbox::DictionaryError::InvalidKey => Self::InvalidKey,
22846
22847                ::fidl_fuchsia_component_sandbox::DictionaryError::NotCloneable => {
22848                    Self::NotCloneable
22849                }
22850
22851                ::fidl_fuchsia_component_sandbox::DictionaryError::__SourceBreaking {
22852                    unknown_ordinal: value,
22853                } => Self::UnknownOrdinal_(value),
22854            }
22855        }
22856    }
22857
22858    impl ::fidl_next::CompatFrom<crate::DictionaryKeysIteratorGetNextResponse>
22859        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse
22860    {
22861        #[inline]
22862        fn compat_from(value: crate::DictionaryKeysIteratorGetNextResponse) -> Self {
22863            Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
22864        }
22865    }
22866
22867    impl
22868        ::fidl_next::CompatFrom<
22869            ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
22870        > for crate::DictionaryKeysIteratorGetNextResponse
22871    {
22872        #[inline]
22873        fn compat_from(
22874            value: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorGetNextResponse,
22875        ) -> Self {
22876            Self { keys: ::fidl_next::CompatFrom::compat_from(value.keys) }
22877        }
22878    }
22879
22880    #[cfg(target_os = "fuchsia")]
22881    /// An alias for a client over `zx::Channel` for the `DictionaryKeysIterator`
22882    /// protocol.
22883    pub type DictionaryKeysIteratorProxy = ::fidl_next::Client<crate::DictionaryKeysIterator>;
22884
22885    impl ::fidl_next::CompatFrom<crate::DictionaryKeysIterator>
22886        for ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker
22887    {
22888        fn compat_from(_: crate::DictionaryKeysIterator) -> Self {
22889            Self
22890        }
22891    }
22892
22893    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker>
22894        for crate::DictionaryKeysIterator
22895    {
22896        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorMarker) -> Self {
22897            Self
22898        }
22899    }
22900
22901    #[cfg(target_os = "fuchsia")]
22902
22903    impl
22904        ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy>
22905        for crate::DictionaryKeysIterator
22906    {
22907        fn client_compat_from(
22908            proxy: ::fidl_fuchsia_component_sandbox::DictionaryKeysIteratorProxy,
22909        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22910            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22911            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22912            ::fidl_next::ClientDispatcher::new(client_end)
22913        }
22914    }
22915
22916    impl ::fidl_next::CompatFrom<crate::DictionaryRouterRouteResponse>
22917        for ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse
22918    {
22919        fn compat_from(value: crate::DictionaryRouterRouteResponse) -> Self {
22920            match value {
22921                crate::DictionaryRouterRouteResponse::Dictionary(value) => {
22922                    Self::Dictionary(::fidl_next::CompatFrom::compat_from(value))
22923                }
22924
22925                crate::DictionaryRouterRouteResponse::Unavailable(value) => {
22926                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22927                }
22928            }
22929        }
22930    }
22931
22932    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse>
22933        for crate::DictionaryRouterRouteResponse
22934    {
22935        fn compat_from(
22936            value: ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse,
22937        ) -> Self {
22938            match value {
22939                ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Dictionary(
22940                    value,
22941                ) => Self::Dictionary(::fidl_next::CompatFrom::compat_from(value)),
22942
22943                ::fidl_fuchsia_component_sandbox::DictionaryRouterRouteResponse::Unavailable(
22944                    value,
22945                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
22946            }
22947        }
22948    }
22949
22950    #[cfg(target_os = "fuchsia")]
22951    /// An alias for a client over `zx::Channel` for the `DictionaryRouter`
22952    /// protocol.
22953    pub type DictionaryRouterProxy = ::fidl_next::Client<crate::DictionaryRouter>;
22954
22955    impl ::fidl_next::CompatFrom<crate::DictionaryRouter>
22956        for ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker
22957    {
22958        fn compat_from(_: crate::DictionaryRouter) -> Self {
22959            Self
22960        }
22961    }
22962
22963    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterMarker>
22964        for crate::DictionaryRouter
22965    {
22966        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DictionaryRouterMarker) -> Self {
22967            Self
22968        }
22969    }
22970
22971    #[cfg(target_os = "fuchsia")]
22972
22973    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DictionaryRouterProxy>
22974        for crate::DictionaryRouter
22975    {
22976        fn client_compat_from(
22977            proxy: ::fidl_fuchsia_component_sandbox::DictionaryRouterProxy,
22978        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
22979            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
22980            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
22981            ::fidl_next::ClientDispatcher::new(client_end)
22982        }
22983    }
22984
22985    impl ::fidl_next::CompatFrom<crate::DirConnectorRouterRouteResponse>
22986        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse
22987    {
22988        fn compat_from(value: crate::DirConnectorRouterRouteResponse) -> Self {
22989            match value {
22990                crate::DirConnectorRouterRouteResponse::DirConnector(value) => {
22991                    Self::DirConnector(::fidl_next::CompatFrom::compat_from(value))
22992                }
22993
22994                crate::DirConnectorRouterRouteResponse::Unavailable(value) => {
22995                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
22996                }
22997            }
22998        }
22999    }
23000
23001    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse>
23002        for crate::DirConnectorRouterRouteResponse
23003    {
23004        fn compat_from(
23005            value: ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse,
23006        ) -> Self {
23007            match value {
23008                ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::DirConnector(
23009                    value,
23010                ) => Self::DirConnector(::fidl_next::CompatFrom::compat_from(value)),
23011
23012                ::fidl_fuchsia_component_sandbox::DirConnectorRouterRouteResponse::Unavailable(
23013                    value,
23014                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23015            }
23016        }
23017    }
23018
23019    #[cfg(target_os = "fuchsia")]
23020    /// An alias for a client over `zx::Channel` for the `DirConnectorRouter`
23021    /// protocol.
23022    pub type DirConnectorRouterProxy = ::fidl_next::Client<crate::DirConnectorRouter>;
23023
23024    impl ::fidl_next::CompatFrom<crate::DirConnectorRouter>
23025        for ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker
23026    {
23027        fn compat_from(_: crate::DirConnectorRouter) -> Self {
23028            Self
23029        }
23030    }
23031
23032    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker>
23033        for crate::DirConnectorRouter
23034    {
23035        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirConnectorRouterMarker) -> Self {
23036            Self
23037        }
23038    }
23039
23040    #[cfg(target_os = "fuchsia")]
23041
23042    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy>
23043        for crate::DirConnectorRouter
23044    {
23045        fn client_compat_from(
23046            proxy: ::fidl_fuchsia_component_sandbox::DirConnectorRouterProxy,
23047        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23048            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23049            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23050            ::fidl_next::ClientDispatcher::new(client_end)
23051        }
23052    }
23053
23054    impl ::fidl_next::CompatFrom<crate::DirEntryRouterRouteResponse>
23055        for ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse
23056    {
23057        fn compat_from(value: crate::DirEntryRouterRouteResponse) -> Self {
23058            match value {
23059                crate::DirEntryRouterRouteResponse::DirEntry(value) => {
23060                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
23061                }
23062
23063                crate::DirEntryRouterRouteResponse::Unavailable(value) => {
23064                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
23065                }
23066            }
23067        }
23068    }
23069
23070    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse>
23071        for crate::DirEntryRouterRouteResponse
23072    {
23073        fn compat_from(
23074            value: ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse,
23075        ) -> Self {
23076            match value {
23077                ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::DirEntry(value) => {
23078                    Self::DirEntry(::fidl_next::CompatFrom::compat_from(value))
23079                }
23080
23081                ::fidl_fuchsia_component_sandbox::DirEntryRouterRouteResponse::Unavailable(
23082                    value,
23083                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23084            }
23085        }
23086    }
23087
23088    #[cfg(target_os = "fuchsia")]
23089    /// An alias for a client over `zx::Channel` for the `DirEntryRouter`
23090    /// protocol.
23091    pub type DirEntryRouterProxy = ::fidl_next::Client<crate::DirEntryRouter>;
23092
23093    impl ::fidl_next::CompatFrom<crate::DirEntryRouter>
23094        for ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker
23095    {
23096        fn compat_from(_: crate::DirEntryRouter) -> Self {
23097            Self
23098        }
23099    }
23100
23101    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterMarker>
23102        for crate::DirEntryRouter
23103    {
23104        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirEntryRouterMarker) -> Self {
23105            Self
23106        }
23107    }
23108
23109    #[cfg(target_os = "fuchsia")]
23110
23111    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirEntryRouterProxy>
23112        for crate::DirEntryRouter
23113    {
23114        fn client_compat_from(
23115            proxy: ::fidl_fuchsia_component_sandbox::DirEntryRouterProxy,
23116        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23117            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23118            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23119            ::fidl_next::ClientDispatcher::new(client_end)
23120        }
23121    }
23122
23123    impl ::fidl_next::CompatFrom<crate::DirReceiverReceiveRequest>
23124        for ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest
23125    {
23126        #[inline]
23127        fn compat_from(value: crate::DirReceiverReceiveRequest) -> Self {
23128            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23129        }
23130    }
23131
23132    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest>
23133        for crate::DirReceiverReceiveRequest
23134    {
23135        #[inline]
23136        fn compat_from(value: ::fidl_fuchsia_component_sandbox::DirReceiverReceiveRequest) -> Self {
23137            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23138        }
23139    }
23140
23141    #[cfg(target_os = "fuchsia")]
23142    /// An alias for a client over `zx::Channel` for the `DirReceiver`
23143    /// protocol.
23144    pub type DirReceiverProxy = ::fidl_next::Client<crate::DirReceiver>;
23145
23146    impl ::fidl_next::CompatFrom<crate::DirReceiver>
23147        for ::fidl_fuchsia_component_sandbox::DirReceiverMarker
23148    {
23149        fn compat_from(_: crate::DirReceiver) -> Self {
23150            Self
23151        }
23152    }
23153
23154    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverMarker>
23155        for crate::DirReceiver
23156    {
23157        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirReceiverMarker) -> Self {
23158            Self
23159        }
23160    }
23161
23162    #[cfg(target_os = "fuchsia")]
23163
23164    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirReceiverProxy>
23165        for crate::DirReceiver
23166    {
23167        fn client_compat_from(
23168            proxy: ::fidl_fuchsia_component_sandbox::DirReceiverProxy,
23169        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23170            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23171            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23172            ::fidl_next::ClientDispatcher::new(client_end)
23173        }
23174    }
23175
23176    impl ::fidl_next::CompatFrom<crate::DirectoryRouterRouteResponse>
23177        for ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse
23178    {
23179        fn compat_from(value: crate::DirectoryRouterRouteResponse) -> Self {
23180            match value {
23181                crate::DirectoryRouterRouteResponse::Directory(value) => {
23182                    Self::Directory(::fidl_next::CompatFrom::compat_from(value))
23183                }
23184
23185                crate::DirectoryRouterRouteResponse::Unavailable(value) => {
23186                    Self::Unavailable(::fidl_next::CompatFrom::compat_from(value))
23187                }
23188            }
23189        }
23190    }
23191
23192    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse>
23193        for crate::DirectoryRouterRouteResponse
23194    {
23195        fn compat_from(
23196            value: ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse,
23197        ) -> Self {
23198            match value {
23199                ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Directory(
23200                    value,
23201                ) => Self::Directory(::fidl_next::CompatFrom::compat_from(value)),
23202
23203                ::fidl_fuchsia_component_sandbox::DirectoryRouterRouteResponse::Unavailable(
23204                    value,
23205                ) => Self::Unavailable(::fidl_next::CompatFrom::compat_from(value)),
23206            }
23207        }
23208    }
23209
23210    #[cfg(target_os = "fuchsia")]
23211    /// An alias for a client over `zx::Channel` for the `DirectoryRouter`
23212    /// protocol.
23213    pub type DirectoryRouterProxy = ::fidl_next::Client<crate::DirectoryRouter>;
23214
23215    impl ::fidl_next::CompatFrom<crate::DirectoryRouter>
23216        for ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker
23217    {
23218        fn compat_from(_: crate::DirectoryRouter) -> Self {
23219            Self
23220        }
23221    }
23222
23223    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterMarker>
23224        for crate::DirectoryRouter
23225    {
23226        fn compat_from(_: ::fidl_fuchsia_component_sandbox::DirectoryRouterMarker) -> Self {
23227            Self
23228        }
23229    }
23230
23231    #[cfg(target_os = "fuchsia")]
23232
23233    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::DirectoryRouterProxy>
23234        for crate::DirectoryRouter
23235    {
23236        fn client_compat_from(
23237            proxy: ::fidl_fuchsia_component_sandbox::DirectoryRouterProxy,
23238        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23239            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23240            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23241            ::fidl_next::ClientDispatcher::new(client_end)
23242        }
23243    }
23244
23245    impl ::fidl_next::CompatFrom<crate::ProtocolPayload>
23246        for ::fidl_fuchsia_component_sandbox::ProtocolPayload
23247    {
23248        #[inline]
23249        fn compat_from(value: crate::ProtocolPayload) -> Self {
23250            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23251        }
23252    }
23253
23254    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ProtocolPayload>
23255        for crate::ProtocolPayload
23256    {
23257        #[inline]
23258        fn compat_from(value: ::fidl_fuchsia_component_sandbox::ProtocolPayload) -> Self {
23259            Self { channel: ::fidl_next::CompatFrom::compat_from(value.channel) }
23260        }
23261    }
23262
23263    #[cfg(target_os = "fuchsia")]
23264    /// An alias for a client over `zx::Channel` for the `Receiver`
23265    /// protocol.
23266    pub type ReceiverProxy = ::fidl_next::Client<crate::Receiver>;
23267
23268    impl ::fidl_next::CompatFrom<crate::Receiver> for ::fidl_fuchsia_component_sandbox::ReceiverMarker {
23269        fn compat_from(_: crate::Receiver) -> Self {
23270            Self
23271        }
23272    }
23273
23274    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::ReceiverMarker> for crate::Receiver {
23275        fn compat_from(_: ::fidl_fuchsia_component_sandbox::ReceiverMarker) -> Self {
23276            Self
23277        }
23278    }
23279
23280    #[cfg(target_os = "fuchsia")]
23281
23282    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_sandbox::ReceiverProxy>
23283        for crate::Receiver
23284    {
23285        fn client_compat_from(
23286            proxy: ::fidl_fuchsia_component_sandbox::ReceiverProxy,
23287        ) -> ::fidl_next::ClientDispatcher<Self, ::fidl_next::fuchsia::zx::Channel> {
23288            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
23289            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
23290            ::fidl_next::ClientDispatcher::new(client_end)
23291        }
23292    }
23293
23294    impl ::fidl_next::CompatFrom<crate::Unavailable> for ::fidl_fuchsia_component_sandbox::Unavailable {
23295        #[inline]
23296        fn compat_from(value: crate::Unavailable) -> Self {
23297            Self {}
23298        }
23299    }
23300
23301    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_sandbox::Unavailable> for crate::Unavailable {
23302        #[inline]
23303        fn compat_from(value: ::fidl_fuchsia_component_sandbox::Unavailable) -> Self {
23304            Self {}
23305        }
23306    }
23307}