fidl_next_common_fuchsia_io/
fidl_next_common_fuchsia_io.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    ::fidl_next::bitflags::bitflags! {
8        #[doc = " The common members definition behind [`Rights`] and [`Abilities`]. Some operations may apply\n only to certain node types (e.g. [`Operations.MODIFY_DIRECTORY`] only applies to directories).\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Operations: u64 {
9            #[doc = " Connecting to a service in a directory.\n"]const CONNECT = 1;
10            #[doc = " Read byte contents of a node or its children.\n"]const READ_BYTES = 2;
11            #[doc = " Writing to the byte contents of a node or its children.\n"]const WRITE_BYTES = 4;
12            #[doc = " Execute the byte contents of a node or its children.\n"]const EXECUTE = 8;
13            #[doc = " Reading the attributes of a node and/or its children.\n"]const GET_ATTRIBUTES = 16;
14            #[doc = " Updating the attributes of a node and/or its children.\n"]const UPDATE_ATTRIBUTES = 32;
15            #[doc = " Reading the list of nodes in a directory.\n"]const ENUMERATE = 64;
16            #[doc = " Opening a node from a directory. Must be specified with [`Rights.ENUMERATE`], as directory\n contents can be probed by opening children.\n"]const TRAVERSE = 128;
17            #[doc = " Modifying the list of nodes in a directory, e.g. creating, renaming, link/unlink, etc...\n Must be specified with [`Rights.ENUMERATE`], as directory contents can be probed via name\n conflicts during node creation.\n"]const MODIFY_DIRECTORY = 256;
18
19        }
20    }
21
22    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Operations, ___E> for Operations
23    where
24        ___E: ?Sized,
25    {
26        #[inline]
27        fn encode(
28            self,
29            encoder: &mut ___E,
30            out: &mut ::core::mem::MaybeUninit<crate::wire::Operations>,
31            _: (),
32        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
33            ::fidl_next::Encode::encode(&self, encoder, out, ())
34        }
35    }
36
37    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Operations, ___E> for &'a Operations
38    where
39        ___E: ?Sized,
40    {
41        #[inline]
42        fn encode(
43            self,
44            _: &mut ___E,
45            out: &mut ::core::mem::MaybeUninit<crate::wire::Operations>,
46            _: (),
47        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
48            ::fidl_next::munge!(let crate::wire::Operations { value } = out);
49
50            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
51                return Err(::fidl_next::EncodeError::InvalidStrictBits);
52            }
53
54            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
55            Ok(())
56        }
57    }
58
59    impl ::core::convert::From<crate::wire::Operations> for Operations {
60        fn from(wire: crate::wire::Operations) -> Self {
61            Self::from_bits_retain(u64::from(wire.value))
62        }
63    }
64
65    impl ::fidl_next::FromWire<crate::wire::Operations> for Operations {
66        #[inline]
67        fn from_wire(wire: crate::wire::Operations) -> Self {
68            Self::from(wire)
69        }
70    }
71
72    impl ::fidl_next::FromWireRef<crate::wire::Operations> for Operations {
73        #[inline]
74        fn from_wire_ref(wire: &crate::wire::Operations) -> Self {
75            Self::from(*wire)
76        }
77    }
78
79    #[doc = " Abilities are properties intrinsic to a node. They specify which operations are supported by it.\n\n Invoking an operation on a node that does not support it results in `ZX_ERR_NOT_SUPPORTED`.\n Note `ZX_ERR_ACCESS_DENIED` takes precedence over `ZX_ERR_NOT_SUPPORTED` when both apply.\n"]
80    pub type Abilities = crate::natural::Operations;
81
82    #[doc = " The reference point for updating the seek offset. See [`File.Seek`].\n\n This enum matches the `zx_stream_seek_origin_t` enum.\n"]
83    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
84    #[repr(u32)]
85    pub enum SeekOrigin {
86        Start = 0,
87        Current = 1,
88        End = 2,
89    }
90    impl ::core::convert::TryFrom<u32> for SeekOrigin {
91        type Error = ::fidl_next::UnknownStrictEnumMemberError;
92        fn try_from(
93            value: u32,
94        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
95            match value {
96                0 => Ok(Self::Start),
97                1 => Ok(Self::Current),
98                2 => Ok(Self::End),
99
100                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
101            }
102        }
103    }
104
105    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for SeekOrigin
106    where
107        ___E: ?Sized,
108    {
109        #[inline]
110        fn encode(
111            self,
112            encoder: &mut ___E,
113            out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
114            _: (),
115        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
116            ::fidl_next::Encode::encode(&self, encoder, out, ())
117        }
118    }
119
120    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for &'a SeekOrigin
121    where
122        ___E: ?Sized,
123    {
124        #[inline]
125        fn encode(
126            self,
127            encoder: &mut ___E,
128            out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
129            _: (),
130        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
131            ::fidl_next::munge!(let crate::wire::SeekOrigin { value } = out);
132            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
133                SeekOrigin::Start => 0,
134
135                SeekOrigin::Current => 1,
136
137                SeekOrigin::End => 2,
138            }));
139
140            Ok(())
141        }
142    }
143
144    impl ::core::convert::From<crate::wire::SeekOrigin> for SeekOrigin {
145        fn from(wire: crate::wire::SeekOrigin) -> Self {
146            match u32::from(wire.value) {
147                0 => Self::Start,
148
149                1 => Self::Current,
150
151                2 => Self::End,
152
153                _ => unsafe { ::core::hint::unreachable_unchecked() },
154            }
155        }
156    }
157
158    impl ::fidl_next::FromWire<crate::wire::SeekOrigin> for SeekOrigin {
159        #[inline]
160        fn from_wire(wire: crate::wire::SeekOrigin) -> Self {
161            Self::from(wire)
162        }
163    }
164
165    impl ::fidl_next::FromWireRef<crate::wire::SeekOrigin> for SeekOrigin {
166        #[inline]
167        fn from_wire_ref(wire: &crate::wire::SeekOrigin) -> Self {
168            Self::from(*wire)
169        }
170    }
171
172    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
173    pub struct AdvisoryLockRange {
174        pub origin: crate::natural::SeekOrigin,
175
176        pub offset: i64,
177
178        pub length: i64,
179    }
180
181    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E> for AdvisoryLockRange
182    where
183        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
184    {
185        #[inline]
186        fn encode(
187            self,
188            encoder_: &mut ___E,
189            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
190            _: (),
191        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
192            ::fidl_next::munge! {
193                let crate::wire::AdvisoryLockRange {
194                    origin,
195                    offset,
196                    length,
197
198                } = out_;
199            }
200
201            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
202
203            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
204
205            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
206
207            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
208
209            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
210
211            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
212
213            Ok(())
214        }
215    }
216
217    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
218        for &'a AdvisoryLockRange
219    where
220        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
221    {
222        #[inline]
223        fn encode(
224            self,
225            encoder_: &mut ___E,
226            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
227            _: (),
228        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
229            ::fidl_next::munge! {
230                let crate::wire::AdvisoryLockRange {
231                    origin,
232                    offset,
233                    length,
234
235                } = out_;
236            }
237
238            ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
239
240            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
241
242            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
243
244            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
245
246            ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
247
248            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
249
250            Ok(())
251        }
252    }
253
254    unsafe impl<___E>
255        ::fidl_next::EncodeOption<
256            ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
257            ___E,
258        > for AdvisoryLockRange
259    where
260        ___E: ::fidl_next::Encoder + ?Sized,
261        AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
262    {
263        #[inline]
264        fn encode_option(
265            this: ::core::option::Option<Self>,
266            encoder: &mut ___E,
267            out: &mut ::core::mem::MaybeUninit<
268                ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
269            >,
270            _: (),
271        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
272            if let Some(inner) = this {
273                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
274                ::fidl_next::wire::Box::encode_present(out);
275            } else {
276                ::fidl_next::wire::Box::encode_absent(out);
277            }
278
279            Ok(())
280        }
281    }
282
283    unsafe impl<'a, ___E>
284        ::fidl_next::EncodeOption<
285            ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
286            ___E,
287        > for &'a AdvisoryLockRange
288    where
289        ___E: ::fidl_next::Encoder + ?Sized,
290        &'a AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
291    {
292        #[inline]
293        fn encode_option(
294            this: ::core::option::Option<Self>,
295            encoder: &mut ___E,
296            out: &mut ::core::mem::MaybeUninit<
297                ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
298            >,
299            _: (),
300        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
301            if let Some(inner) = this {
302                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
303                ::fidl_next::wire::Box::encode_present(out);
304            } else {
305                ::fidl_next::wire::Box::encode_absent(out);
306            }
307
308            Ok(())
309        }
310    }
311
312    impl ::fidl_next::FromWire<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
313        #[inline]
314        fn from_wire(wire: crate::wire::AdvisoryLockRange) -> Self {
315            Self {
316                origin: ::fidl_next::FromWire::from_wire(wire.origin),
317
318                offset: ::fidl_next::FromWire::from_wire(wire.offset),
319
320                length: ::fidl_next::FromWire::from_wire(wire.length),
321            }
322        }
323    }
324
325    impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
326        #[inline]
327        fn from_wire_ref(wire: &crate::wire::AdvisoryLockRange) -> Self {
328            Self {
329                origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
330
331                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
332
333                length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length),
334            }
335        }
336    }
337
338    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
339    #[repr(u32)]
340    pub enum AdvisoryLockType {
341        Read = 1,
342        Write = 2,
343        Unlock = 3,
344    }
345    impl ::core::convert::TryFrom<u32> for AdvisoryLockType {
346        type Error = ::fidl_next::UnknownStrictEnumMemberError;
347        fn try_from(
348            value: u32,
349        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
350            match value {
351                1 => Ok(Self::Read),
352                2 => Ok(Self::Write),
353                3 => Ok(Self::Unlock),
354
355                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
356            }
357        }
358    }
359
360    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E> for AdvisoryLockType
361    where
362        ___E: ?Sized,
363    {
364        #[inline]
365        fn encode(
366            self,
367            encoder: &mut ___E,
368            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
369            _: (),
370        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
371            ::fidl_next::Encode::encode(&self, encoder, out, ())
372        }
373    }
374
375    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E>
376        for &'a AdvisoryLockType
377    where
378        ___E: ?Sized,
379    {
380        #[inline]
381        fn encode(
382            self,
383            encoder: &mut ___E,
384            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
385            _: (),
386        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
387            ::fidl_next::munge!(let crate::wire::AdvisoryLockType { value } = out);
388            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
389                AdvisoryLockType::Read => 1,
390
391                AdvisoryLockType::Write => 2,
392
393                AdvisoryLockType::Unlock => 3,
394            }));
395
396            Ok(())
397        }
398    }
399
400    impl ::core::convert::From<crate::wire::AdvisoryLockType> for AdvisoryLockType {
401        fn from(wire: crate::wire::AdvisoryLockType) -> Self {
402            match u32::from(wire.value) {
403                1 => Self::Read,
404
405                2 => Self::Write,
406
407                3 => Self::Unlock,
408
409                _ => unsafe { ::core::hint::unreachable_unchecked() },
410            }
411        }
412    }
413
414    impl ::fidl_next::FromWire<crate::wire::AdvisoryLockType> for AdvisoryLockType {
415        #[inline]
416        fn from_wire(wire: crate::wire::AdvisoryLockType) -> Self {
417            Self::from(wire)
418        }
419    }
420
421    impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockType> for AdvisoryLockType {
422        #[inline]
423        fn from_wire_ref(wire: &crate::wire::AdvisoryLockType) -> Self {
424            Self::from(*wire)
425        }
426    }
427
428    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
429    pub struct AdvisoryLockRequest {
430        pub type_: ::core::option::Option<crate::natural::AdvisoryLockType>,
431
432        pub range: ::core::option::Option<crate::natural::AdvisoryLockRange>,
433
434        pub wait: ::core::option::Option<bool>,
435    }
436
437    impl AdvisoryLockRequest {
438        fn __max_ordinal(&self) -> usize {
439            if self.wait.is_some() {
440                return 3;
441            }
442
443            if self.range.is_some() {
444                return 2;
445            }
446
447            if self.type_.is_some() {
448                return 1;
449            }
450
451            0
452        }
453    }
454
455    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
456        for AdvisoryLockRequest
457    where
458        ___E: ::fidl_next::Encoder + ?Sized,
459    {
460        #[inline]
461        fn encode(
462            mut self,
463            encoder: &mut ___E,
464            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
465            _: (),
466        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
467            ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
468
469            let max_ord = self.__max_ordinal();
470
471            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
472            ::fidl_next::Wire::zero_padding(&mut out);
473
474            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
475                ::fidl_next::wire::Envelope,
476            >(encoder, max_ord);
477
478            for i in 1..=max_ord {
479                match i {
480                    3 => {
481                        if let Some(value) = self.wait.take() {
482                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
483                                value,
484                                preallocated.encoder,
485                                &mut out,
486                                (),
487                            )?;
488                        } else {
489                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
490                        }
491                    }
492
493                    2 => {
494                        if let Some(value) = self.range.take() {
495                            ::fidl_next::wire::Envelope::encode_value::<
496                                crate::wire::AdvisoryLockRange,
497                                ___E,
498                            >(
499                                value, preallocated.encoder, &mut out, ()
500                            )?;
501                        } else {
502                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
503                        }
504                    }
505
506                    1 => {
507                        if let Some(value) = self.type_.take() {
508                            ::fidl_next::wire::Envelope::encode_value::<
509                                crate::wire::AdvisoryLockType,
510                                ___E,
511                            >(
512                                value, preallocated.encoder, &mut out, ()
513                            )?;
514                        } else {
515                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
516                        }
517                    }
518
519                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
520                }
521                unsafe {
522                    preallocated.write_next(out.assume_init_ref());
523                }
524            }
525
526            ::fidl_next::wire::Table::encode_len(table, max_ord);
527
528            Ok(())
529        }
530    }
531
532    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
533        for &'a AdvisoryLockRequest
534    where
535        ___E: ::fidl_next::Encoder + ?Sized,
536    {
537        #[inline]
538        fn encode(
539            self,
540            encoder: &mut ___E,
541            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
542            _: (),
543        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
544            ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
545
546            let max_ord = self.__max_ordinal();
547
548            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
549            ::fidl_next::Wire::zero_padding(&mut out);
550
551            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
552                ::fidl_next::wire::Envelope,
553            >(encoder, max_ord);
554
555            for i in 1..=max_ord {
556                match i {
557                    3 => {
558                        if let Some(value) = &self.wait {
559                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
560                                value,
561                                preallocated.encoder,
562                                &mut out,
563                                (),
564                            )?;
565                        } else {
566                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
567                        }
568                    }
569
570                    2 => {
571                        if let Some(value) = &self.range {
572                            ::fidl_next::wire::Envelope::encode_value::<
573                                crate::wire::AdvisoryLockRange,
574                                ___E,
575                            >(
576                                value, preallocated.encoder, &mut out, ()
577                            )?;
578                        } else {
579                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
580                        }
581                    }
582
583                    1 => {
584                        if let Some(value) = &self.type_ {
585                            ::fidl_next::wire::Envelope::encode_value::<
586                                crate::wire::AdvisoryLockType,
587                                ___E,
588                            >(
589                                value, preallocated.encoder, &mut out, ()
590                            )?;
591                        } else {
592                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
593                        }
594                    }
595
596                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
597                }
598                unsafe {
599                    preallocated.write_next(out.assume_init_ref());
600                }
601            }
602
603            ::fidl_next::wire::Table::encode_len(table, max_ord);
604
605            Ok(())
606        }
607    }
608
609    impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
610        #[inline]
611        fn from_wire(wire_: crate::wire::AdvisoryLockRequest<'de>) -> Self {
612            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
613
614            let type_ = wire_.table.get(1);
615
616            let range = wire_.table.get(2);
617
618            let wait = wire_.table.get(3);
619
620            Self {
621                type_: type_.map(|envelope| {
622                    ::fidl_next::FromWire::from_wire(unsafe {
623                        envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
624                    })
625                }),
626
627                range: range.map(|envelope| {
628                    ::fidl_next::FromWire::from_wire(unsafe {
629                        envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
630                    })
631                }),
632
633                wait: wait.map(|envelope| {
634                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
635                }),
636            }
637        }
638    }
639
640    impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
641        #[inline]
642        fn from_wire_ref(wire: &crate::wire::AdvisoryLockRequest<'de>) -> Self {
643            Self {
644                type_: wire.table.get(1).map(|envelope| {
645                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
646                        envelope.deref_unchecked::<crate::wire::AdvisoryLockType>()
647                    })
648                }),
649
650                range: wire.table.get(2).map(|envelope| {
651                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
652                        envelope.deref_unchecked::<crate::wire::AdvisoryLockRange>()
653                    })
654                }),
655
656                wait: wire.table.get(3).map(|envelope| {
657                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
658                        envelope.deref_unchecked::<bool>()
659                    })
660                }),
661            }
662        }
663    }
664
665    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
666    pub struct AdvisoryLockingAdvisoryLockRequest {
667        pub request: crate::natural::AdvisoryLockRequest,
668    }
669
670    unsafe impl<___E>
671        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
672        for AdvisoryLockingAdvisoryLockRequest
673    where
674        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
675        ___E: ::fidl_next::Encoder,
676    {
677        #[inline]
678        fn encode(
679            self,
680            encoder_: &mut ___E,
681            out_: &mut ::core::mem::MaybeUninit<
682                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
683            >,
684            _: (),
685        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
686            ::fidl_next::munge! {
687                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
688                    request,
689
690                } = out_;
691            }
692
693            ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
694
695            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
696
697            Ok(())
698        }
699    }
700
701    unsafe impl<'a, ___E>
702        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
703        for &'a AdvisoryLockingAdvisoryLockRequest
704    where
705        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
706        ___E: ::fidl_next::Encoder,
707    {
708        #[inline]
709        fn encode(
710            self,
711            encoder_: &mut ___E,
712            out_: &mut ::core::mem::MaybeUninit<
713                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
714            >,
715            _: (),
716        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
717            ::fidl_next::munge! {
718                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
719                    request,
720
721                } = out_;
722            }
723
724            ::fidl_next::Encode::encode(&self.request, encoder_, request, ())?;
725
726            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
727
728            Ok(())
729        }
730    }
731
732    unsafe impl<___E>
733        ::fidl_next::EncodeOption<
734            ::fidl_next::wire::Box<
735                'static,
736                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
737            >,
738            ___E,
739        > for AdvisoryLockingAdvisoryLockRequest
740    where
741        ___E: ::fidl_next::Encoder + ?Sized,
742        AdvisoryLockingAdvisoryLockRequest:
743            ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
744    {
745        #[inline]
746        fn encode_option(
747            this: ::core::option::Option<Self>,
748            encoder: &mut ___E,
749            out: &mut ::core::mem::MaybeUninit<
750                ::fidl_next::wire::Box<
751                    'static,
752                    crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
753                >,
754            >,
755            _: (),
756        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
757            if let Some(inner) = this {
758                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
759                ::fidl_next::wire::Box::encode_present(out);
760            } else {
761                ::fidl_next::wire::Box::encode_absent(out);
762            }
763
764            Ok(())
765        }
766    }
767
768    unsafe impl<'a, ___E>
769        ::fidl_next::EncodeOption<
770            ::fidl_next::wire::Box<
771                'static,
772                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
773            >,
774            ___E,
775        > for &'a AdvisoryLockingAdvisoryLockRequest
776    where
777        ___E: ::fidl_next::Encoder + ?Sized,
778        &'a AdvisoryLockingAdvisoryLockRequest:
779            ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
780    {
781        #[inline]
782        fn encode_option(
783            this: ::core::option::Option<Self>,
784            encoder: &mut ___E,
785            out: &mut ::core::mem::MaybeUninit<
786                ::fidl_next::wire::Box<
787                    'static,
788                    crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
789                >,
790            >,
791            _: (),
792        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
793            if let Some(inner) = this {
794                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
795                ::fidl_next::wire::Box::encode_present(out);
796            } else {
797                ::fidl_next::wire::Box::encode_absent(out);
798            }
799
800            Ok(())
801        }
802    }
803
804    impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
805        for AdvisoryLockingAdvisoryLockRequest
806    {
807        #[inline]
808        fn from_wire(wire: crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
809            Self { request: ::fidl_next::FromWire::from_wire(wire.request) }
810        }
811    }
812
813    impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
814        for AdvisoryLockingAdvisoryLockRequest
815    {
816        #[inline]
817        fn from_wire_ref(wire: &crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
818            Self { request: ::fidl_next::FromWireRef::from_wire_ref(&wire.request) }
819        }
820    }
821
822    pub type AdvisoryLockingAdvisoryLockResponse = ();
823
824    ::fidl_next::bitflags::bitflags! {
825        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct AllocateMode: u32 {
826            const KEEP_SIZE = 1;
827            const UNSHARE_RANGE = 2;
828            const PUNCH_HOLE = 4;
829            const COLLAPSE_RANGE = 8;
830            const ZERO_RANGE = 16;
831            const INSERT_RANGE = 32;
832            const _ = !0;
833        }
834    }
835
836    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for AllocateMode
837    where
838        ___E: ?Sized,
839    {
840        #[inline]
841        fn encode(
842            self,
843            encoder: &mut ___E,
844            out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
845            _: (),
846        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
847            ::fidl_next::Encode::encode(&self, encoder, out, ())
848        }
849    }
850
851    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for &'a AllocateMode
852    where
853        ___E: ?Sized,
854    {
855        #[inline]
856        fn encode(
857            self,
858            _: &mut ___E,
859            out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
860            _: (),
861        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
862            ::fidl_next::munge!(let crate::wire::AllocateMode { value } = out);
863
864            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
865            Ok(())
866        }
867    }
868
869    impl ::core::convert::From<crate::wire::AllocateMode> for AllocateMode {
870        fn from(wire: crate::wire::AllocateMode) -> Self {
871            Self::from_bits_retain(u32::from(wire.value))
872        }
873    }
874
875    impl ::fidl_next::FromWire<crate::wire::AllocateMode> for AllocateMode {
876        #[inline]
877        fn from_wire(wire: crate::wire::AllocateMode) -> Self {
878            Self::from(wire)
879        }
880    }
881
882    impl ::fidl_next::FromWireRef<crate::wire::AllocateMode> for AllocateMode {
883        #[inline]
884        fn from_wire_ref(wire: &crate::wire::AllocateMode) -> Self {
885            Self::from(*wire)
886        }
887    }
888
889    #[doc = " Rights are properties specific to a connection. They limit which operations are allowed on a\n connection, including those which may be granted to new connections.\n\n Invoking an operation without the corresponding right results in `ZX_ERR_ACCESS_DENIED`\n even if the node does not have support for the operation.\n"]
890    pub type Rights = crate::natural::Operations;
891
892    #[doc = " The type to identify a node, if the implementation supports some notion of\n unique node ID.\n\n ## Uniqueness Guarantees\n\n A client is usually presented with a directory tree that is the result\n of composing together multiple backing implementation instances. An ID\n would be unique within the corresponding instance only.\n Their boundaries are rather implicit on Fuchsia, as a result of\n transparently-forwarding directory proxies. It could be common for a client\n to observe identical `Id`s when traversing a directory tree, when it\n encounters nodes from different backing instances. Therefore, the ID is best\n used for debugging and informational purposes.\n\n The [`fuchsia.fs/FilesystemInfo.fs_id`] field may be used to disambiguate\n IDs from different backing instances.\n"]
893    pub type Id = u64;
894
895    ::fidl_next::bitflags::bitflags! {
896        #[doc = " DEPRECATED - Use Flags instead.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct OpenFlags: u32 {
897            #[doc = " Can read from target object.\n"]const RIGHT_READABLE = 1;
898            #[doc = " Can write to target object.\n"]const RIGHT_WRITABLE = 2;
899            #[doc = " Connection can map target object executable.\n"]const RIGHT_EXECUTABLE = 8;
900            #[doc = " Create the object if it doesn\'t exist.\n"]const CREATE = 65536;
901            #[doc = " (with Create) Fail if the object already exists.\n"]const CREATE_IF_ABSENT = 131072;
902            #[doc = " Truncate the object before usage.\n"]const TRUNCATE = 262144;
903            #[doc = " Assert that the object to be opened is a directory.\n Return an error if the target object is not a directory.\n"]const DIRECTORY = 524288;
904            #[doc = " Seek to the end of the object before all writes.\n"]const APPEND = 1048576;
905            #[doc = " Open a reference to the object, not the object itself.\n It is ONLY valid to pass the following flags together with `NODE_REFERENCE`:\n - `DIRECTORY`\n - `NOT_DIRECTORY`\n - `DESCRIBE`\n otherwise an error is returned.\n If an object is opened or cloned using this method, the resulting connection does not carry\n any permission flags.\n The resulting connection allows a limited set of operations: `GetAttr`, `Clone`, `Close`,\n `Describe`, and `GetFlags`. The connection will speak the `Node` protocol. Calling `SetAttr`\n or `SetFlags` will result in `ZX_ERR_BAD_HANDLE`.\n"]const NODE_REFERENCE = 4194304;
906            #[doc = " Requests that an \"OnOpen\" event is sent to the interface request.\n\n The event will contain a non-null `NodeInfoDeprecated` if the open/clone is successful. This\n can be used to open a protocol that does not compose fuchsia.io/Node; the event is sent as\n if the protocol is fuchsia.io/Node and then the target protocol is used exclusively.\n"]const DESCRIBE = 8388608;
907            #[doc = " Specify this flag to request POSIX-compatibility with respect to write permission handling.\n Currently, it affects permission handling specifically during Open:\n - If the target path is a directory, the rights on the new connection expand to include\n   `WRITABLE` if and only if the current connection and all intermediate mount points\n   are writable.\n - Otherwise, this flag is ignored. It is an access denied error to request more rights\n   than those on the current connection, or any intermediate mount points.\n\n If this flag is omitted, opening always uses the requested rights, failing the operation with\n access denied error if requested rights exceeds the rights attached to the current connection.\n\n If the requesting connection is read-only and the requested rights are read-only, the flag\n may be ignored by the server, and is not forwarded downstream. This is an implementation detail,\n necessary to enforce hierarchical permissions across mount points, and should have no effect\n on the expected behavior for clients.\n"]const POSIX_WRITABLE = 134217728;
908            #[doc = " Specify this flag to request POSIX-compatibility with respect to execute permission handling.\n Currently, it affects permission handling specifically during Open:\n - If the target path is a directory, the rights on the new connection expand to include\n   `EXECUTABLE` if and only if the current connection and all intermediate mount\n   points are executable.\n - Otherwise, this flag is ignored. It is an access denied error to request more rights\n   than those on the current connection, or any intermediate mount points.\n\n If this flag is omitted, opening always uses the requested rights, failing the operation with\n access denied error if requested rights exceeds the rights attached to the current connection.\n\n If the requesting connection is read-only and the requested rights are read-only, the flag\n may be ignored by the server, and is not forwarded downstream. This is an implementation detail,\n necessary to enforce hierarchical permissions across mount points, and should have no effect\n on the expected behavior for clients.\n"]const POSIX_EXECUTABLE = 268435456;
909            #[doc = " Assert that the object to be opened is not a directory.\n Return an error if the target object is a directory.\n"]const NOT_DIRECTORY = 33554432;
910            #[doc = " When used during clone, the new connection inherits the rights on the source connection,\n regardless if it is a file or directory. Otherwise, clone attempts to use the requested rights.\n It is invalid to pass any of the `RIGHT_*` flags together with `OpenFlags.CLONE_SAME_RIGHTS`.\n"]const CLONE_SAME_RIGHTS = 67108864;
911            #[doc = " Open the target object as a block device.\n"]const BLOCK_DEVICE = 16777216;
912
913        }
914    }
915
916    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for OpenFlags
917    where
918        ___E: ?Sized,
919    {
920        #[inline]
921        fn encode(
922            self,
923            encoder: &mut ___E,
924            out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
925            _: (),
926        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
927            ::fidl_next::Encode::encode(&self, encoder, out, ())
928        }
929    }
930
931    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for &'a OpenFlags
932    where
933        ___E: ?Sized,
934    {
935        #[inline]
936        fn encode(
937            self,
938            _: &mut ___E,
939            out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
940            _: (),
941        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
942            ::fidl_next::munge!(let crate::wire::OpenFlags { value } = out);
943
944            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
945                return Err(::fidl_next::EncodeError::InvalidStrictBits);
946            }
947
948            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
949            Ok(())
950        }
951    }
952
953    impl ::core::convert::From<crate::wire::OpenFlags> for OpenFlags {
954        fn from(wire: crate::wire::OpenFlags) -> Self {
955            Self::from_bits_retain(u32::from(wire.value))
956        }
957    }
958
959    impl ::fidl_next::FromWire<crate::wire::OpenFlags> for OpenFlags {
960        #[inline]
961        fn from_wire(wire: crate::wire::OpenFlags) -> Self {
962            Self::from(wire)
963        }
964    }
965
966    impl ::fidl_next::FromWireRef<crate::wire::OpenFlags> for OpenFlags {
967        #[inline]
968        fn from_wire_ref(wire: &crate::wire::OpenFlags) -> Self {
969            Self::from(*wire)
970        }
971    }
972
973    #[doc = " NodeAttributes defines generic information about a filesystem node.\n"]
974    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
975    pub struct NodeAttributes {
976        pub mode: u32,
977
978        pub id: u64,
979
980        pub content_size: u64,
981
982        pub storage_size: u64,
983
984        pub link_count: u64,
985
986        pub creation_time: u64,
987
988        pub modification_time: u64,
989    }
990
991    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for NodeAttributes
992    where
993        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
994    {
995        #[inline]
996        fn encode(
997            self,
998            encoder_: &mut ___E,
999            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
1000            _: (),
1001        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1002            ::fidl_next::munge! {
1003                let crate::wire::NodeAttributes {
1004                    mode,
1005                    id,
1006                    content_size,
1007                    storage_size,
1008                    link_count,
1009                    creation_time,
1010                    modification_time,
1011
1012                } = out_;
1013            }
1014
1015            ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1016
1017            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1018
1019            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1020
1021            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1022
1023            ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
1024
1025            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1026
1027            ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
1028
1029            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1030
1031            ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
1032
1033            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1034
1035            ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
1036
1037            let mut _field =
1038                unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1039
1040            ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
1041
1042            let mut _field =
1043                unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1044
1045            Ok(())
1046        }
1047    }
1048
1049    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for &'a NodeAttributes
1050    where
1051        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1052    {
1053        #[inline]
1054        fn encode(
1055            self,
1056            encoder_: &mut ___E,
1057            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
1058            _: (),
1059        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1060            ::fidl_next::munge! {
1061                let crate::wire::NodeAttributes {
1062                    mode,
1063                    id,
1064                    content_size,
1065                    storage_size,
1066                    link_count,
1067                    creation_time,
1068                    modification_time,
1069
1070                } = out_;
1071            }
1072
1073            ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
1074
1075            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1076
1077            ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1078
1079            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1080
1081            ::fidl_next::Encode::encode(&self.content_size, encoder_, content_size, ())?;
1082
1083            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1084
1085            ::fidl_next::Encode::encode(&self.storage_size, encoder_, storage_size, ())?;
1086
1087            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1088
1089            ::fidl_next::Encode::encode(&self.link_count, encoder_, link_count, ())?;
1090
1091            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1092
1093            ::fidl_next::Encode::encode(&self.creation_time, encoder_, creation_time, ())?;
1094
1095            let mut _field =
1096                unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1097
1098            ::fidl_next::Encode::encode(&self.modification_time, encoder_, modification_time, ())?;
1099
1100            let mut _field =
1101                unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1102
1103            Ok(())
1104        }
1105    }
1106
1107    unsafe impl<___E>
1108        ::fidl_next::EncodeOption<
1109            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1110            ___E,
1111        > for NodeAttributes
1112    where
1113        ___E: ::fidl_next::Encoder + ?Sized,
1114        NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1115    {
1116        #[inline]
1117        fn encode_option(
1118            this: ::core::option::Option<Self>,
1119            encoder: &mut ___E,
1120            out: &mut ::core::mem::MaybeUninit<
1121                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1122            >,
1123            _: (),
1124        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1125            if let Some(inner) = this {
1126                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1127                ::fidl_next::wire::Box::encode_present(out);
1128            } else {
1129                ::fidl_next::wire::Box::encode_absent(out);
1130            }
1131
1132            Ok(())
1133        }
1134    }
1135
1136    unsafe impl<'a, ___E>
1137        ::fidl_next::EncodeOption<
1138            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1139            ___E,
1140        > for &'a NodeAttributes
1141    where
1142        ___E: ::fidl_next::Encoder + ?Sized,
1143        &'a NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1144    {
1145        #[inline]
1146        fn encode_option(
1147            this: ::core::option::Option<Self>,
1148            encoder: &mut ___E,
1149            out: &mut ::core::mem::MaybeUninit<
1150                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1151            >,
1152            _: (),
1153        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1154            if let Some(inner) = this {
1155                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1156                ::fidl_next::wire::Box::encode_present(out);
1157            } else {
1158                ::fidl_next::wire::Box::encode_absent(out);
1159            }
1160
1161            Ok(())
1162        }
1163    }
1164
1165    impl ::fidl_next::FromWire<crate::wire::NodeAttributes> for NodeAttributes {
1166        #[inline]
1167        fn from_wire(wire: crate::wire::NodeAttributes) -> Self {
1168            Self {
1169                mode: ::fidl_next::FromWire::from_wire(wire.mode),
1170
1171                id: ::fidl_next::FromWire::from_wire(wire.id),
1172
1173                content_size: ::fidl_next::FromWire::from_wire(wire.content_size),
1174
1175                storage_size: ::fidl_next::FromWire::from_wire(wire.storage_size),
1176
1177                link_count: ::fidl_next::FromWire::from_wire(wire.link_count),
1178
1179                creation_time: ::fidl_next::FromWire::from_wire(wire.creation_time),
1180
1181                modification_time: ::fidl_next::FromWire::from_wire(wire.modification_time),
1182            }
1183        }
1184    }
1185
1186    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributes> for NodeAttributes {
1187        #[inline]
1188        fn from_wire_ref(wire: &crate::wire::NodeAttributes) -> Self {
1189            Self {
1190                mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
1191
1192                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1193
1194                content_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.content_size),
1195
1196                storage_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.storage_size),
1197
1198                link_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.link_count),
1199
1200                creation_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.creation_time),
1201
1202                modification_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.modification_time),
1203            }
1204        }
1205    }
1206
1207    ::fidl_next::bitflags::bitflags! {
1208        #[doc = " The fields of \'attributes\' which are used to update the Node are indicated\n by the \'flags\' argument.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeAttributeFlags: u32 {
1209            const CREATION_TIME = 1;
1210            const MODIFICATION_TIME = 2;
1211
1212        }
1213    }
1214
1215    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E> for NodeAttributeFlags
1216    where
1217        ___E: ?Sized,
1218    {
1219        #[inline]
1220        fn encode(
1221            self,
1222            encoder: &mut ___E,
1223            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1224            _: (),
1225        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1226            ::fidl_next::Encode::encode(&self, encoder, out, ())
1227        }
1228    }
1229
1230    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>
1231        for &'a NodeAttributeFlags
1232    where
1233        ___E: ?Sized,
1234    {
1235        #[inline]
1236        fn encode(
1237            self,
1238            _: &mut ___E,
1239            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1240            _: (),
1241        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1242            ::fidl_next::munge!(let crate::wire::NodeAttributeFlags { value } = out);
1243
1244            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1245                return Err(::fidl_next::EncodeError::InvalidStrictBits);
1246            }
1247
1248            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1249            Ok(())
1250        }
1251    }
1252
1253    impl ::core::convert::From<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1254        fn from(wire: crate::wire::NodeAttributeFlags) -> Self {
1255            Self::from_bits_retain(u32::from(wire.value))
1256        }
1257    }
1258
1259    impl ::fidl_next::FromWire<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1260        #[inline]
1261        fn from_wire(wire: crate::wire::NodeAttributeFlags) -> Self {
1262            Self::from(wire)
1263        }
1264    }
1265
1266    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1267        #[inline]
1268        fn from_wire_ref(wire: &crate::wire::NodeAttributeFlags) -> Self {
1269            Self::from(*wire)
1270        }
1271    }
1272
1273    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1274    pub struct NodeQueryFilesystemResponse {
1275        pub s: ::fidl_next::fuchsia::zx::Status,
1276
1277        pub info: ::core::option::Option<::std::boxed::Box<crate::natural::FilesystemInfo>>,
1278    }
1279
1280    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1281        for NodeQueryFilesystemResponse
1282    where
1283        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1284        ___E: ::fidl_next::Encoder,
1285    {
1286        #[inline]
1287        fn encode(
1288            self,
1289            encoder_: &mut ___E,
1290            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1291            _: (),
1292        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1293            ::fidl_next::munge! {
1294                let crate::wire::NodeQueryFilesystemResponse {
1295                    s,
1296                    info,
1297
1298                } = out_;
1299            }
1300
1301            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1302
1303            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1304
1305            ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1306
1307            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1308
1309            Ok(())
1310        }
1311    }
1312
1313    unsafe impl<'a, ___E>
1314        ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1315        for &'a NodeQueryFilesystemResponse
1316    where
1317        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1318        ___E: ::fidl_next::Encoder,
1319    {
1320        #[inline]
1321        fn encode(
1322            self,
1323            encoder_: &mut ___E,
1324            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1325            _: (),
1326        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1327            ::fidl_next::munge! {
1328                let crate::wire::NodeQueryFilesystemResponse {
1329                    s,
1330                    info,
1331
1332                } = out_;
1333            }
1334
1335            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1336
1337            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1338
1339            ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
1340
1341            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1342
1343            Ok(())
1344        }
1345    }
1346
1347    unsafe impl<___E>
1348        ::fidl_next::EncodeOption<
1349            ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1350            ___E,
1351        > for NodeQueryFilesystemResponse
1352    where
1353        ___E: ::fidl_next::Encoder + ?Sized,
1354        NodeQueryFilesystemResponse:
1355            ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1356    {
1357        #[inline]
1358        fn encode_option(
1359            this: ::core::option::Option<Self>,
1360            encoder: &mut ___E,
1361            out: &mut ::core::mem::MaybeUninit<
1362                ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1363            >,
1364            _: (),
1365        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1366            if let Some(inner) = this {
1367                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1368                ::fidl_next::wire::Box::encode_present(out);
1369            } else {
1370                ::fidl_next::wire::Box::encode_absent(out);
1371            }
1372
1373            Ok(())
1374        }
1375    }
1376
1377    unsafe impl<'a, ___E>
1378        ::fidl_next::EncodeOption<
1379            ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1380            ___E,
1381        > for &'a NodeQueryFilesystemResponse
1382    where
1383        ___E: ::fidl_next::Encoder + ?Sized,
1384        &'a NodeQueryFilesystemResponse:
1385            ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1386    {
1387        #[inline]
1388        fn encode_option(
1389            this: ::core::option::Option<Self>,
1390            encoder: &mut ___E,
1391            out: &mut ::core::mem::MaybeUninit<
1392                ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1393            >,
1394            _: (),
1395        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1396            if let Some(inner) = this {
1397                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1398                ::fidl_next::wire::Box::encode_present(out);
1399            } else {
1400                ::fidl_next::wire::Box::encode_absent(out);
1401            }
1402
1403            Ok(())
1404        }
1405    }
1406
1407    impl<'de> ::fidl_next::FromWire<crate::wire::NodeQueryFilesystemResponse<'de>>
1408        for NodeQueryFilesystemResponse
1409    {
1410        #[inline]
1411        fn from_wire(wire: crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1412            Self {
1413                s: ::fidl_next::FromWire::from_wire(wire.s),
1414
1415                info: ::fidl_next::FromWire::from_wire(wire.info),
1416            }
1417        }
1418    }
1419
1420    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeQueryFilesystemResponse<'de>>
1421        for NodeQueryFilesystemResponse
1422    {
1423        #[inline]
1424        fn from_wire_ref(wire: &crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1425            Self {
1426                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
1427
1428                info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info),
1429            }
1430        }
1431    }
1432
1433    pub type NodeUpdateAttributesResponse = ();
1434
1435    pub type NodeSyncResponse = ();
1436
1437    ::fidl_next::bitflags::bitflags! {
1438        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct ModeType: u32 {
1439            const DO_NOT_USE = 2147483648;
1440
1441        }
1442    }
1443
1444    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for ModeType
1445    where
1446        ___E: ?Sized,
1447    {
1448        #[inline]
1449        fn encode(
1450            self,
1451            encoder: &mut ___E,
1452            out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1453            _: (),
1454        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1455            ::fidl_next::Encode::encode(&self, encoder, out, ())
1456        }
1457    }
1458
1459    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for &'a ModeType
1460    where
1461        ___E: ?Sized,
1462    {
1463        #[inline]
1464        fn encode(
1465            self,
1466            _: &mut ___E,
1467            out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1468            _: (),
1469        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1470            ::fidl_next::munge!(let crate::wire::ModeType { value } = out);
1471
1472            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1473                return Err(::fidl_next::EncodeError::InvalidStrictBits);
1474            }
1475
1476            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1477            Ok(())
1478        }
1479    }
1480
1481    impl ::core::convert::From<crate::wire::ModeType> for ModeType {
1482        fn from(wire: crate::wire::ModeType) -> Self {
1483            Self::from_bits_retain(u32::from(wire.value))
1484        }
1485    }
1486
1487    impl ::fidl_next::FromWire<crate::wire::ModeType> for ModeType {
1488        #[inline]
1489        fn from_wire(wire: crate::wire::ModeType) -> Self {
1490            Self::from(wire)
1491        }
1492    }
1493
1494    impl ::fidl_next::FromWireRef<crate::wire::ModeType> for ModeType {
1495        #[inline]
1496        fn from_wire_ref(wire: &crate::wire::ModeType) -> Self {
1497            Self::from(*wire)
1498        }
1499    }
1500
1501    #[doc = " A path is a string of one or more components, separated by \"/\".\n E.g. `foo/bar/baz`\n\n ## Invariants\n\n A valid path must meet the following criteria:\n\n * It cannot be empty.\n * It cannot be longer than [`MAX_PATH_LENGTH`].\n * It cannot have a leading \"/\".\n * It cannot have a trailing \"/\".\n * It must be exactly \".\" OR each of its components must be a valid [`Name`].\n\n Paths should be transformed into their canonical forms at client side.\n For example, a client should convert `\"foo/bar/.././baz/\"` to `\"foo/baz\"`\n before using it as a path.\n"]
1502    pub type Path = ::std::string::String;
1503
1504    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1505    #[repr(C)]
1506    pub struct DirectoryReadDirentsRequest {
1507        pub max_bytes: u64,
1508    }
1509
1510    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1511        for DirectoryReadDirentsRequest
1512    where
1513        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1514    {
1515        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1516            Self,
1517            crate::wire::DirectoryReadDirentsRequest,
1518        > = unsafe {
1519            ::fidl_next::CopyOptimization::enable_if(
1520            true
1521
1522                && <
1523                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1524                >::COPY_OPTIMIZATION.is_enabled()
1525
1526        )
1527        };
1528
1529        #[inline]
1530        fn encode(
1531            self,
1532            encoder_: &mut ___E,
1533            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1534            _: (),
1535        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1536            ::fidl_next::munge! {
1537                let crate::wire::DirectoryReadDirentsRequest {
1538                    max_bytes,
1539
1540                } = out_;
1541            }
1542
1543            ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
1544
1545            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1546
1547            Ok(())
1548        }
1549    }
1550
1551    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1552        for &'a DirectoryReadDirentsRequest
1553    where
1554        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1555    {
1556        #[inline]
1557        fn encode(
1558            self,
1559            encoder_: &mut ___E,
1560            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1561            _: (),
1562        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1563            ::fidl_next::munge! {
1564                let crate::wire::DirectoryReadDirentsRequest {
1565                    max_bytes,
1566
1567                } = out_;
1568            }
1569
1570            ::fidl_next::Encode::encode(&self.max_bytes, encoder_, max_bytes, ())?;
1571
1572            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1573
1574            Ok(())
1575        }
1576    }
1577
1578    unsafe impl<___E>
1579        ::fidl_next::EncodeOption<
1580            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1581            ___E,
1582        > for DirectoryReadDirentsRequest
1583    where
1584        ___E: ::fidl_next::Encoder + ?Sized,
1585        DirectoryReadDirentsRequest:
1586            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
1587    {
1588        #[inline]
1589        fn encode_option(
1590            this: ::core::option::Option<Self>,
1591            encoder: &mut ___E,
1592            out: &mut ::core::mem::MaybeUninit<
1593                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1594            >,
1595            _: (),
1596        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1597            if let Some(inner) = this {
1598                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1599                ::fidl_next::wire::Box::encode_present(out);
1600            } else {
1601                ::fidl_next::wire::Box::encode_absent(out);
1602            }
1603
1604            Ok(())
1605        }
1606    }
1607
1608    unsafe impl<'a, ___E>
1609        ::fidl_next::EncodeOption<
1610            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1611            ___E,
1612        > for &'a DirectoryReadDirentsRequest
1613    where
1614        ___E: ::fidl_next::Encoder + ?Sized,
1615        &'a DirectoryReadDirentsRequest:
1616            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
1617    {
1618        #[inline]
1619        fn encode_option(
1620            this: ::core::option::Option<Self>,
1621            encoder: &mut ___E,
1622            out: &mut ::core::mem::MaybeUninit<
1623                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1624            >,
1625            _: (),
1626        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1627            if let Some(inner) = this {
1628                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1629                ::fidl_next::wire::Box::encode_present(out);
1630            } else {
1631                ::fidl_next::wire::Box::encode_absent(out);
1632            }
1633
1634            Ok(())
1635        }
1636    }
1637
1638    impl ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsRequest>
1639        for DirectoryReadDirentsRequest
1640    {
1641        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1642            crate::wire::DirectoryReadDirentsRequest,
1643            Self,
1644        > = unsafe {
1645            ::fidl_next::CopyOptimization::enable_if(
1646                true
1647                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1648                        .is_enabled(),
1649            )
1650        };
1651
1652        #[inline]
1653        fn from_wire(wire: crate::wire::DirectoryReadDirentsRequest) -> Self {
1654            Self { max_bytes: ::fidl_next::FromWire::from_wire(wire.max_bytes) }
1655        }
1656    }
1657
1658    impl ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsRequest>
1659        for DirectoryReadDirentsRequest
1660    {
1661        #[inline]
1662        fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsRequest) -> Self {
1663            Self { max_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_bytes) }
1664        }
1665    }
1666
1667    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1668    pub struct DirectoryReadDirentsResponse {
1669        pub s: ::fidl_next::fuchsia::zx::Status,
1670
1671        pub dirents: ::std::vec::Vec<u8>,
1672    }
1673
1674    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
1675        for DirectoryReadDirentsResponse
1676    where
1677        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1678        ___E: ::fidl_next::Encoder,
1679    {
1680        #[inline]
1681        fn encode(
1682            self,
1683            encoder_: &mut ___E,
1684            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
1685            _: (),
1686        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1687            ::fidl_next::munge! {
1688                let crate::wire::DirectoryReadDirentsResponse {
1689                    s,
1690                    dirents,
1691
1692                } = out_;
1693            }
1694
1695            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1696
1697            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1698
1699            ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
1700
1701            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
1702            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
1703
1704            Ok(())
1705        }
1706    }
1707
1708    unsafe impl<'a, ___E>
1709        ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
1710        for &'a DirectoryReadDirentsResponse
1711    where
1712        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1713        ___E: ::fidl_next::Encoder,
1714    {
1715        #[inline]
1716        fn encode(
1717            self,
1718            encoder_: &mut ___E,
1719            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
1720            _: (),
1721        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1722            ::fidl_next::munge! {
1723                let crate::wire::DirectoryReadDirentsResponse {
1724                    s,
1725                    dirents,
1726
1727                } = out_;
1728            }
1729
1730            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1731
1732            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1733
1734            ::fidl_next::Encode::encode(&self.dirents, encoder_, dirents, (8192, ()))?;
1735
1736            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
1737            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
1738
1739            Ok(())
1740        }
1741    }
1742
1743    unsafe impl<___E>
1744        ::fidl_next::EncodeOption<
1745            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1746            ___E,
1747        > for DirectoryReadDirentsResponse
1748    where
1749        ___E: ::fidl_next::Encoder + ?Sized,
1750        DirectoryReadDirentsResponse:
1751            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
1752    {
1753        #[inline]
1754        fn encode_option(
1755            this: ::core::option::Option<Self>,
1756            encoder: &mut ___E,
1757            out: &mut ::core::mem::MaybeUninit<
1758                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1759            >,
1760            _: (),
1761        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1762            if let Some(inner) = this {
1763                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1764                ::fidl_next::wire::Box::encode_present(out);
1765            } else {
1766                ::fidl_next::wire::Box::encode_absent(out);
1767            }
1768
1769            Ok(())
1770        }
1771    }
1772
1773    unsafe impl<'a, ___E>
1774        ::fidl_next::EncodeOption<
1775            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1776            ___E,
1777        > for &'a DirectoryReadDirentsResponse
1778    where
1779        ___E: ::fidl_next::Encoder + ?Sized,
1780        &'a DirectoryReadDirentsResponse:
1781            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
1782    {
1783        #[inline]
1784        fn encode_option(
1785            this: ::core::option::Option<Self>,
1786            encoder: &mut ___E,
1787            out: &mut ::core::mem::MaybeUninit<
1788                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1789            >,
1790            _: (),
1791        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1792            if let Some(inner) = this {
1793                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1794                ::fidl_next::wire::Box::encode_present(out);
1795            } else {
1796                ::fidl_next::wire::Box::encode_absent(out);
1797            }
1798
1799            Ok(())
1800        }
1801    }
1802
1803    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsResponse<'de>>
1804        for DirectoryReadDirentsResponse
1805    {
1806        #[inline]
1807        fn from_wire(wire: crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
1808            Self {
1809                s: ::fidl_next::FromWire::from_wire(wire.s),
1810
1811                dirents: ::fidl_next::FromWire::from_wire(wire.dirents),
1812            }
1813        }
1814    }
1815
1816    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsResponse<'de>>
1817        for DirectoryReadDirentsResponse
1818    {
1819        #[inline]
1820        fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
1821            Self {
1822                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
1823
1824                dirents: ::fidl_next::FromWireRef::from_wire_ref(&wire.dirents),
1825            }
1826        }
1827    }
1828
1829    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1830    #[repr(C)]
1831    pub struct DirectoryRewindResponse {
1832        pub s: ::fidl_next::fuchsia::zx::Status,
1833    }
1834
1835    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
1836        for DirectoryRewindResponse
1837    where
1838        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1839    {
1840        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1841            Self,
1842            crate::wire::DirectoryRewindResponse,
1843        > = unsafe {
1844            ::fidl_next::CopyOptimization::enable_if(
1845                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
1846                    ::fidl_next::wire::fuchsia::Status,
1847                    ___E,
1848                >>::COPY_OPTIMIZATION
1849                    .is_enabled(),
1850            )
1851        };
1852
1853        #[inline]
1854        fn encode(
1855            self,
1856            encoder_: &mut ___E,
1857            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
1858            _: (),
1859        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1860            ::fidl_next::munge! {
1861                let crate::wire::DirectoryRewindResponse {
1862                    s,
1863
1864                } = out_;
1865            }
1866
1867            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1868
1869            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1870
1871            Ok(())
1872        }
1873    }
1874
1875    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
1876        for &'a DirectoryRewindResponse
1877    where
1878        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1879    {
1880        #[inline]
1881        fn encode(
1882            self,
1883            encoder_: &mut ___E,
1884            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
1885            _: (),
1886        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1887            ::fidl_next::munge! {
1888                let crate::wire::DirectoryRewindResponse {
1889                    s,
1890
1891                } = out_;
1892            }
1893
1894            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1895
1896            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1897
1898            Ok(())
1899        }
1900    }
1901
1902    unsafe impl<___E>
1903        ::fidl_next::EncodeOption<
1904            ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1905            ___E,
1906        > for DirectoryRewindResponse
1907    where
1908        ___E: ::fidl_next::Encoder + ?Sized,
1909        DirectoryRewindResponse: ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
1910    {
1911        #[inline]
1912        fn encode_option(
1913            this: ::core::option::Option<Self>,
1914            encoder: &mut ___E,
1915            out: &mut ::core::mem::MaybeUninit<
1916                ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1917            >,
1918            _: (),
1919        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1920            if let Some(inner) = this {
1921                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1922                ::fidl_next::wire::Box::encode_present(out);
1923            } else {
1924                ::fidl_next::wire::Box::encode_absent(out);
1925            }
1926
1927            Ok(())
1928        }
1929    }
1930
1931    unsafe impl<'a, ___E>
1932        ::fidl_next::EncodeOption<
1933            ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1934            ___E,
1935        > for &'a DirectoryRewindResponse
1936    where
1937        ___E: ::fidl_next::Encoder + ?Sized,
1938        &'a DirectoryRewindResponse:
1939            ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
1940    {
1941        #[inline]
1942        fn encode_option(
1943            this: ::core::option::Option<Self>,
1944            encoder: &mut ___E,
1945            out: &mut ::core::mem::MaybeUninit<
1946                ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1947            >,
1948            _: (),
1949        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1950            if let Some(inner) = this {
1951                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1952                ::fidl_next::wire::Box::encode_present(out);
1953            } else {
1954                ::fidl_next::wire::Box::encode_absent(out);
1955            }
1956
1957            Ok(())
1958        }
1959    }
1960
1961    impl ::fidl_next::FromWire<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
1962        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1963            crate::wire::DirectoryRewindResponse,
1964            Self,
1965        > = unsafe {
1966            ::fidl_next::CopyOptimization::enable_if(
1967                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
1968                    ::fidl_next::wire::fuchsia::Status,
1969                >>::COPY_OPTIMIZATION
1970                    .is_enabled(),
1971            )
1972        };
1973
1974        #[inline]
1975        fn from_wire(wire: crate::wire::DirectoryRewindResponse) -> Self {
1976            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
1977        }
1978    }
1979
1980    impl ::fidl_next::FromWireRef<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
1981        #[inline]
1982        fn from_wire_ref(wire: &crate::wire::DirectoryRewindResponse) -> Self {
1983            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
1984        }
1985    }
1986
1987    #[doc = " The type for the name of a node, i.e. a single path component.\n E.g. `foo`\n\n ## Invariants\n\n A valid node name must meet the following criteria:\n\n * It cannot be longer than [`MAX_NAME_LENGTH`].\n * It cannot be empty.\n * It cannot be \"..\" (dot-dot).\n * It cannot be \".\" (single dot).\n * It cannot contain \"/\".\n * It cannot contain embedded NUL.\n"]
1988    pub type Name = ::std::string::String;
1989
1990    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1991    #[repr(C)]
1992    pub struct DirectoryLinkResponse {
1993        pub s: ::fidl_next::fuchsia::zx::Status,
1994    }
1995
1996    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
1997        for DirectoryLinkResponse
1998    where
1999        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2000    {
2001        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2002            Self,
2003            crate::wire::DirectoryLinkResponse,
2004        > = unsafe {
2005            ::fidl_next::CopyOptimization::enable_if(
2006                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
2007                    ::fidl_next::wire::fuchsia::Status,
2008                    ___E,
2009                >>::COPY_OPTIMIZATION
2010                    .is_enabled(),
2011            )
2012        };
2013
2014        #[inline]
2015        fn encode(
2016            self,
2017            encoder_: &mut ___E,
2018            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2019            _: (),
2020        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2021            ::fidl_next::munge! {
2022                let crate::wire::DirectoryLinkResponse {
2023                    s,
2024
2025                } = out_;
2026            }
2027
2028            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2029
2030            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2031
2032            Ok(())
2033        }
2034    }
2035
2036    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
2037        for &'a DirectoryLinkResponse
2038    where
2039        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2040    {
2041        #[inline]
2042        fn encode(
2043            self,
2044            encoder_: &mut ___E,
2045            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2046            _: (),
2047        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2048            ::fidl_next::munge! {
2049                let crate::wire::DirectoryLinkResponse {
2050                    s,
2051
2052                } = out_;
2053            }
2054
2055            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2056
2057            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2058
2059            Ok(())
2060        }
2061    }
2062
2063    unsafe impl<___E>
2064        ::fidl_next::EncodeOption<
2065            ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2066            ___E,
2067        > for DirectoryLinkResponse
2068    where
2069        ___E: ::fidl_next::Encoder + ?Sized,
2070        DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2071    {
2072        #[inline]
2073        fn encode_option(
2074            this: ::core::option::Option<Self>,
2075            encoder: &mut ___E,
2076            out: &mut ::core::mem::MaybeUninit<
2077                ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2078            >,
2079            _: (),
2080        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2081            if let Some(inner) = this {
2082                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2083                ::fidl_next::wire::Box::encode_present(out);
2084            } else {
2085                ::fidl_next::wire::Box::encode_absent(out);
2086            }
2087
2088            Ok(())
2089        }
2090    }
2091
2092    unsafe impl<'a, ___E>
2093        ::fidl_next::EncodeOption<
2094            ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2095            ___E,
2096        > for &'a DirectoryLinkResponse
2097    where
2098        ___E: ::fidl_next::Encoder + ?Sized,
2099        &'a DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2100    {
2101        #[inline]
2102        fn encode_option(
2103            this: ::core::option::Option<Self>,
2104            encoder: &mut ___E,
2105            out: &mut ::core::mem::MaybeUninit<
2106                ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2107            >,
2108            _: (),
2109        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2110            if let Some(inner) = this {
2111                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2112                ::fidl_next::wire::Box::encode_present(out);
2113            } else {
2114                ::fidl_next::wire::Box::encode_absent(out);
2115            }
2116
2117            Ok(())
2118        }
2119    }
2120
2121    impl ::fidl_next::FromWire<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2122        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2123            crate::wire::DirectoryLinkResponse,
2124            Self,
2125        > = unsafe {
2126            ::fidl_next::CopyOptimization::enable_if(
2127                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
2128                    ::fidl_next::wire::fuchsia::Status,
2129                >>::COPY_OPTIMIZATION
2130                    .is_enabled(),
2131            )
2132        };
2133
2134        #[inline]
2135        fn from_wire(wire: crate::wire::DirectoryLinkResponse) -> Self {
2136            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2137        }
2138    }
2139
2140    impl ::fidl_next::FromWireRef<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2141        #[inline]
2142        fn from_wire_ref(wire: &crate::wire::DirectoryLinkResponse) -> Self {
2143            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2144        }
2145    }
2146
2147    ::fidl_next::bitflags::bitflags! {
2148        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct UnlinkFlags: u64 {
2149            #[doc = " If set, the unlink will fail (with ZX_ERR_NOT_DIR) if the\n object is not a directory.\n"]const MUST_BE_DIRECTORY = 1;
2150            const _ = !0;
2151        }
2152    }
2153
2154    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for UnlinkFlags
2155    where
2156        ___E: ?Sized,
2157    {
2158        #[inline]
2159        fn encode(
2160            self,
2161            encoder: &mut ___E,
2162            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2163            _: (),
2164        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2165            ::fidl_next::Encode::encode(&self, encoder, out, ())
2166        }
2167    }
2168
2169    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for &'a UnlinkFlags
2170    where
2171        ___E: ?Sized,
2172    {
2173        #[inline]
2174        fn encode(
2175            self,
2176            _: &mut ___E,
2177            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2178            _: (),
2179        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2180            ::fidl_next::munge!(let crate::wire::UnlinkFlags { value } = out);
2181
2182            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
2183            Ok(())
2184        }
2185    }
2186
2187    impl ::core::convert::From<crate::wire::UnlinkFlags> for UnlinkFlags {
2188        fn from(wire: crate::wire::UnlinkFlags) -> Self {
2189            Self::from_bits_retain(u64::from(wire.value))
2190        }
2191    }
2192
2193    impl ::fidl_next::FromWire<crate::wire::UnlinkFlags> for UnlinkFlags {
2194        #[inline]
2195        fn from_wire(wire: crate::wire::UnlinkFlags) -> Self {
2196            Self::from(wire)
2197        }
2198    }
2199
2200    impl ::fidl_next::FromWireRef<crate::wire::UnlinkFlags> for UnlinkFlags {
2201        #[inline]
2202        fn from_wire_ref(wire: &crate::wire::UnlinkFlags) -> Self {
2203            Self::from(*wire)
2204        }
2205    }
2206
2207    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2208    pub struct UnlinkOptions {
2209        pub flags: ::core::option::Option<crate::natural::UnlinkFlags>,
2210    }
2211
2212    impl UnlinkOptions {
2213        fn __max_ordinal(&self) -> usize {
2214            if self.flags.is_some() {
2215                return 1;
2216            }
2217
2218            0
2219        }
2220    }
2221
2222    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E> for UnlinkOptions
2223    where
2224        ___E: ::fidl_next::Encoder + ?Sized,
2225    {
2226        #[inline]
2227        fn encode(
2228            mut self,
2229            encoder: &mut ___E,
2230            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2231            _: (),
2232        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2233            ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2234
2235            let max_ord = self.__max_ordinal();
2236
2237            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2238            ::fidl_next::Wire::zero_padding(&mut out);
2239
2240            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2241                ::fidl_next::wire::Envelope,
2242            >(encoder, max_ord);
2243
2244            for i in 1..=max_ord {
2245                match i {
2246                    1 => {
2247                        if let Some(value) = self.flags.take() {
2248                            ::fidl_next::wire::Envelope::encode_value::<
2249                                crate::wire::UnlinkFlags,
2250                                ___E,
2251                            >(
2252                                value, preallocated.encoder, &mut out, ()
2253                            )?;
2254                        } else {
2255                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
2256                        }
2257                    }
2258
2259                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2260                }
2261                unsafe {
2262                    preallocated.write_next(out.assume_init_ref());
2263                }
2264            }
2265
2266            ::fidl_next::wire::Table::encode_len(table, max_ord);
2267
2268            Ok(())
2269        }
2270    }
2271
2272    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>
2273        for &'a UnlinkOptions
2274    where
2275        ___E: ::fidl_next::Encoder + ?Sized,
2276    {
2277        #[inline]
2278        fn encode(
2279            self,
2280            encoder: &mut ___E,
2281            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2282            _: (),
2283        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2284            ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2285
2286            let max_ord = self.__max_ordinal();
2287
2288            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2289            ::fidl_next::Wire::zero_padding(&mut out);
2290
2291            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2292                ::fidl_next::wire::Envelope,
2293            >(encoder, max_ord);
2294
2295            for i in 1..=max_ord {
2296                match i {
2297                    1 => {
2298                        if let Some(value) = &self.flags {
2299                            ::fidl_next::wire::Envelope::encode_value::<
2300                                crate::wire::UnlinkFlags,
2301                                ___E,
2302                            >(
2303                                value, preallocated.encoder, &mut out, ()
2304                            )?;
2305                        } else {
2306                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
2307                        }
2308                    }
2309
2310                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2311                }
2312                unsafe {
2313                    preallocated.write_next(out.assume_init_ref());
2314                }
2315            }
2316
2317            ::fidl_next::wire::Table::encode_len(table, max_ord);
2318
2319            Ok(())
2320        }
2321    }
2322
2323    impl<'de> ::fidl_next::FromWire<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2324        #[inline]
2325        fn from_wire(wire_: crate::wire::UnlinkOptions<'de>) -> Self {
2326            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2327
2328            let flags = wire_.table.get(1);
2329
2330            Self {
2331                flags: flags.map(|envelope| {
2332                    ::fidl_next::FromWire::from_wire(unsafe {
2333                        envelope.read_unchecked::<crate::wire::UnlinkFlags>()
2334                    })
2335                }),
2336            }
2337        }
2338    }
2339
2340    impl<'de> ::fidl_next::FromWireRef<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2341        #[inline]
2342        fn from_wire_ref(wire: &crate::wire::UnlinkOptions<'de>) -> Self {
2343            Self {
2344                flags: wire.table.get(1).map(|envelope| {
2345                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2346                        envelope.deref_unchecked::<crate::wire::UnlinkFlags>()
2347                    })
2348                }),
2349            }
2350        }
2351    }
2352
2353    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2354    pub struct DirectoryUnlinkRequest {
2355        pub name: ::std::string::String,
2356
2357        pub options: crate::natural::UnlinkOptions,
2358    }
2359
2360    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2361        for DirectoryUnlinkRequest
2362    where
2363        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2364        ___E: ::fidl_next::Encoder,
2365    {
2366        #[inline]
2367        fn encode(
2368            self,
2369            encoder_: &mut ___E,
2370            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2371            _: (),
2372        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2373            ::fidl_next::munge! {
2374                let crate::wire::DirectoryUnlinkRequest {
2375                    name,
2376                    options,
2377
2378                } = out_;
2379            }
2380
2381            ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
2382
2383            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2384            ::fidl_next::Constrained::validate(_field, 255)?;
2385
2386            ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2387
2388            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2389
2390            Ok(())
2391        }
2392    }
2393
2394    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2395        for &'a DirectoryUnlinkRequest
2396    where
2397        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2398        ___E: ::fidl_next::Encoder,
2399    {
2400        #[inline]
2401        fn encode(
2402            self,
2403            encoder_: &mut ___E,
2404            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2405            _: (),
2406        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2407            ::fidl_next::munge! {
2408                let crate::wire::DirectoryUnlinkRequest {
2409                    name,
2410                    options,
2411
2412                } = out_;
2413            }
2414
2415            ::fidl_next::Encode::encode(&self.name, encoder_, name, 255)?;
2416
2417            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2418            ::fidl_next::Constrained::validate(_field, 255)?;
2419
2420            ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
2421
2422            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2423
2424            Ok(())
2425        }
2426    }
2427
2428    unsafe impl<___E>
2429        ::fidl_next::EncodeOption<
2430            ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2431            ___E,
2432        > for DirectoryUnlinkRequest
2433    where
2434        ___E: ::fidl_next::Encoder + ?Sized,
2435        DirectoryUnlinkRequest:
2436            ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2437    {
2438        #[inline]
2439        fn encode_option(
2440            this: ::core::option::Option<Self>,
2441            encoder: &mut ___E,
2442            out: &mut ::core::mem::MaybeUninit<
2443                ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2444            >,
2445            _: (),
2446        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2447            if let Some(inner) = this {
2448                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2449                ::fidl_next::wire::Box::encode_present(out);
2450            } else {
2451                ::fidl_next::wire::Box::encode_absent(out);
2452            }
2453
2454            Ok(())
2455        }
2456    }
2457
2458    unsafe impl<'a, ___E>
2459        ::fidl_next::EncodeOption<
2460            ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2461            ___E,
2462        > for &'a DirectoryUnlinkRequest
2463    where
2464        ___E: ::fidl_next::Encoder + ?Sized,
2465        &'a DirectoryUnlinkRequest:
2466            ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2467    {
2468        #[inline]
2469        fn encode_option(
2470            this: ::core::option::Option<Self>,
2471            encoder: &mut ___E,
2472            out: &mut ::core::mem::MaybeUninit<
2473                ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2474            >,
2475            _: (),
2476        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2477            if let Some(inner) = this {
2478                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2479                ::fidl_next::wire::Box::encode_present(out);
2480            } else {
2481                ::fidl_next::wire::Box::encode_absent(out);
2482            }
2483
2484            Ok(())
2485        }
2486    }
2487
2488    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryUnlinkRequest<'de>>
2489        for DirectoryUnlinkRequest
2490    {
2491        #[inline]
2492        fn from_wire(wire: crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2493            Self {
2494                name: ::fidl_next::FromWire::from_wire(wire.name),
2495
2496                options: ::fidl_next::FromWire::from_wire(wire.options),
2497            }
2498        }
2499    }
2500
2501    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryUnlinkRequest<'de>>
2502        for DirectoryUnlinkRequest
2503    {
2504        #[inline]
2505        fn from_wire_ref(wire: &crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2506            Self {
2507                name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
2508
2509                options: ::fidl_next::FromWireRef::from_wire_ref(&wire.options),
2510            }
2511        }
2512    }
2513
2514    pub type DirectoryUnlinkResponse = ();
2515
2516    pub type DirectoryRenameResponse = ();
2517
2518    ::fidl_next::bitflags::bitflags! {
2519        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct WatchMask: u32 {
2520            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.DELETED`.\n"]const DELETED = 1;
2521            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.ADDED`.\n"]const ADDED = 2;
2522            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.REMOVED`.\n"]const REMOVED = 4;
2523            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.EXISTING`.\n"]const EXISTING = 8;
2524            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.IDLE`.\n"]const IDLE = 16;
2525
2526        }
2527    }
2528
2529    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for WatchMask
2530    where
2531        ___E: ?Sized,
2532    {
2533        #[inline]
2534        fn encode(
2535            self,
2536            encoder: &mut ___E,
2537            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
2538            _: (),
2539        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2540            ::fidl_next::Encode::encode(&self, encoder, out, ())
2541        }
2542    }
2543
2544    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for &'a WatchMask
2545    where
2546        ___E: ?Sized,
2547    {
2548        #[inline]
2549        fn encode(
2550            self,
2551            _: &mut ___E,
2552            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
2553            _: (),
2554        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2555            ::fidl_next::munge!(let crate::wire::WatchMask { value } = out);
2556
2557            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
2558                return Err(::fidl_next::EncodeError::InvalidStrictBits);
2559            }
2560
2561            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
2562            Ok(())
2563        }
2564    }
2565
2566    impl ::core::convert::From<crate::wire::WatchMask> for WatchMask {
2567        fn from(wire: crate::wire::WatchMask) -> Self {
2568            Self::from_bits_retain(u32::from(wire.value))
2569        }
2570    }
2571
2572    impl ::fidl_next::FromWire<crate::wire::WatchMask> for WatchMask {
2573        #[inline]
2574        fn from_wire(wire: crate::wire::WatchMask) -> Self {
2575            Self::from(wire)
2576        }
2577    }
2578
2579    impl ::fidl_next::FromWireRef<crate::wire::WatchMask> for WatchMask {
2580        #[inline]
2581        fn from_wire_ref(wire: &crate::wire::WatchMask) -> Self {
2582            Self::from(*wire)
2583        }
2584    }
2585
2586    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2587    #[repr(C)]
2588    pub struct DirectoryWatchResponse {
2589        pub s: ::fidl_next::fuchsia::zx::Status,
2590    }
2591
2592    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
2593        for DirectoryWatchResponse
2594    where
2595        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2596    {
2597        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2598            Self,
2599            crate::wire::DirectoryWatchResponse,
2600        > = unsafe {
2601            ::fidl_next::CopyOptimization::enable_if(
2602                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
2603                    ::fidl_next::wire::fuchsia::Status,
2604                    ___E,
2605                >>::COPY_OPTIMIZATION
2606                    .is_enabled(),
2607            )
2608        };
2609
2610        #[inline]
2611        fn encode(
2612            self,
2613            encoder_: &mut ___E,
2614            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
2615            _: (),
2616        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2617            ::fidl_next::munge! {
2618                let crate::wire::DirectoryWatchResponse {
2619                    s,
2620
2621                } = out_;
2622            }
2623
2624            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2625
2626            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2627
2628            Ok(())
2629        }
2630    }
2631
2632    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
2633        for &'a DirectoryWatchResponse
2634    where
2635        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2636    {
2637        #[inline]
2638        fn encode(
2639            self,
2640            encoder_: &mut ___E,
2641            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
2642            _: (),
2643        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2644            ::fidl_next::munge! {
2645                let crate::wire::DirectoryWatchResponse {
2646                    s,
2647
2648                } = out_;
2649            }
2650
2651            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2652
2653            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2654
2655            Ok(())
2656        }
2657    }
2658
2659    unsafe impl<___E>
2660        ::fidl_next::EncodeOption<
2661            ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2662            ___E,
2663        > for DirectoryWatchResponse
2664    where
2665        ___E: ::fidl_next::Encoder + ?Sized,
2666        DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
2667    {
2668        #[inline]
2669        fn encode_option(
2670            this: ::core::option::Option<Self>,
2671            encoder: &mut ___E,
2672            out: &mut ::core::mem::MaybeUninit<
2673                ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2674            >,
2675            _: (),
2676        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2677            if let Some(inner) = this {
2678                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2679                ::fidl_next::wire::Box::encode_present(out);
2680            } else {
2681                ::fidl_next::wire::Box::encode_absent(out);
2682            }
2683
2684            Ok(())
2685        }
2686    }
2687
2688    unsafe impl<'a, ___E>
2689        ::fidl_next::EncodeOption<
2690            ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2691            ___E,
2692        > for &'a DirectoryWatchResponse
2693    where
2694        ___E: ::fidl_next::Encoder + ?Sized,
2695        &'a DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
2696    {
2697        #[inline]
2698        fn encode_option(
2699            this: ::core::option::Option<Self>,
2700            encoder: &mut ___E,
2701            out: &mut ::core::mem::MaybeUninit<
2702                ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2703            >,
2704            _: (),
2705        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2706            if let Some(inner) = this {
2707                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2708                ::fidl_next::wire::Box::encode_present(out);
2709            } else {
2710                ::fidl_next::wire::Box::encode_absent(out);
2711            }
2712
2713            Ok(())
2714        }
2715    }
2716
2717    impl ::fidl_next::FromWire<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
2718        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2719            crate::wire::DirectoryWatchResponse,
2720            Self,
2721        > = unsafe {
2722            ::fidl_next::CopyOptimization::enable_if(
2723                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
2724                    ::fidl_next::wire::fuchsia::Status,
2725                >>::COPY_OPTIMIZATION
2726                    .is_enabled(),
2727            )
2728        };
2729
2730        #[inline]
2731        fn from_wire(wire: crate::wire::DirectoryWatchResponse) -> Self {
2732            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2733        }
2734    }
2735
2736    impl ::fidl_next::FromWireRef<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
2737        #[inline]
2738        fn from_wire_ref(wire: &crate::wire::DirectoryWatchResponse) -> Self {
2739            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2740        }
2741    }
2742
2743    pub type SymlinkTarget = ::std::vec::Vec<u8>;
2744
2745    #[doc = " The name of an extended attribute. It can not contain any null bytes. Other\n than that and the maximum size, no particular structure is imposed on the\n name.\n"]
2746    pub type ExtendedAttributeName = ::std::vec::Vec<u8>;
2747
2748    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2749    pub struct NodeGetExtendedAttributeRequest {
2750        pub name: ::std::vec::Vec<u8>,
2751    }
2752
2753    unsafe impl<___E>
2754        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
2755        for NodeGetExtendedAttributeRequest
2756    where
2757        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2758        ___E: ::fidl_next::Encoder,
2759    {
2760        #[inline]
2761        fn encode(
2762            self,
2763            encoder_: &mut ___E,
2764            out_: &mut ::core::mem::MaybeUninit<
2765                crate::wire::NodeGetExtendedAttributeRequest<'static>,
2766            >,
2767            _: (),
2768        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2769            ::fidl_next::munge! {
2770                let crate::wire::NodeGetExtendedAttributeRequest {
2771                    name,
2772
2773                } = out_;
2774            }
2775
2776            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
2777
2778            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2779            ::fidl_next::Constrained::validate(_field, (255, ()))?;
2780
2781            Ok(())
2782        }
2783    }
2784
2785    unsafe impl<'a, ___E>
2786        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
2787        for &'a NodeGetExtendedAttributeRequest
2788    where
2789        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2790        ___E: ::fidl_next::Encoder,
2791    {
2792        #[inline]
2793        fn encode(
2794            self,
2795            encoder_: &mut ___E,
2796            out_: &mut ::core::mem::MaybeUninit<
2797                crate::wire::NodeGetExtendedAttributeRequest<'static>,
2798            >,
2799            _: (),
2800        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2801            ::fidl_next::munge! {
2802                let crate::wire::NodeGetExtendedAttributeRequest {
2803                    name,
2804
2805                } = out_;
2806            }
2807
2808            ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
2809
2810            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2811            ::fidl_next::Constrained::validate(_field, (255, ()))?;
2812
2813            Ok(())
2814        }
2815    }
2816
2817    unsafe impl<___E>
2818        ::fidl_next::EncodeOption<
2819            ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
2820            ___E,
2821        > for NodeGetExtendedAttributeRequest
2822    where
2823        ___E: ::fidl_next::Encoder + ?Sized,
2824        NodeGetExtendedAttributeRequest:
2825            ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
2826    {
2827        #[inline]
2828        fn encode_option(
2829            this: ::core::option::Option<Self>,
2830            encoder: &mut ___E,
2831            out: &mut ::core::mem::MaybeUninit<
2832                ::fidl_next::wire::Box<
2833                    'static,
2834                    crate::wire::NodeGetExtendedAttributeRequest<'static>,
2835                >,
2836            >,
2837            _: (),
2838        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2839            if let Some(inner) = this {
2840                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2841                ::fidl_next::wire::Box::encode_present(out);
2842            } else {
2843                ::fidl_next::wire::Box::encode_absent(out);
2844            }
2845
2846            Ok(())
2847        }
2848    }
2849
2850    unsafe impl<'a, ___E>
2851        ::fidl_next::EncodeOption<
2852            ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
2853            ___E,
2854        > for &'a NodeGetExtendedAttributeRequest
2855    where
2856        ___E: ::fidl_next::Encoder + ?Sized,
2857        &'a NodeGetExtendedAttributeRequest:
2858            ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
2859    {
2860        #[inline]
2861        fn encode_option(
2862            this: ::core::option::Option<Self>,
2863            encoder: &mut ___E,
2864            out: &mut ::core::mem::MaybeUninit<
2865                ::fidl_next::wire::Box<
2866                    'static,
2867                    crate::wire::NodeGetExtendedAttributeRequest<'static>,
2868                >,
2869            >,
2870            _: (),
2871        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2872            if let Some(inner) = this {
2873                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2874                ::fidl_next::wire::Box::encode_present(out);
2875            } else {
2876                ::fidl_next::wire::Box::encode_absent(out);
2877            }
2878
2879            Ok(())
2880        }
2881    }
2882
2883    impl<'de> ::fidl_next::FromWire<crate::wire::NodeGetExtendedAttributeRequest<'de>>
2884        for NodeGetExtendedAttributeRequest
2885    {
2886        #[inline]
2887        fn from_wire(wire: crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
2888            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
2889        }
2890    }
2891
2892    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeGetExtendedAttributeRequest<'de>>
2893        for NodeGetExtendedAttributeRequest
2894    {
2895        #[inline]
2896        fn from_wire_ref(wire: &crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
2897            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
2898        }
2899    }
2900
2901    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2902    #[repr(u32)]
2903    pub enum SetExtendedAttributeMode {
2904        Set = 1,
2905        Create = 2,
2906        Replace = 3,
2907    }
2908    impl ::core::convert::TryFrom<u32> for SetExtendedAttributeMode {
2909        type Error = ::fidl_next::UnknownStrictEnumMemberError;
2910        fn try_from(
2911            value: u32,
2912        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
2913            match value {
2914                1 => Ok(Self::Set),
2915                2 => Ok(Self::Create),
2916                3 => Ok(Self::Replace),
2917
2918                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
2919            }
2920        }
2921    }
2922
2923    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
2924        for SetExtendedAttributeMode
2925    where
2926        ___E: ?Sized,
2927    {
2928        #[inline]
2929        fn encode(
2930            self,
2931            encoder: &mut ___E,
2932            out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
2933            _: (),
2934        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2935            ::fidl_next::Encode::encode(&self, encoder, out, ())
2936        }
2937    }
2938
2939    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
2940        for &'a SetExtendedAttributeMode
2941    where
2942        ___E: ?Sized,
2943    {
2944        #[inline]
2945        fn encode(
2946            self,
2947            encoder: &mut ___E,
2948            out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
2949            _: (),
2950        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2951            ::fidl_next::munge!(let crate::wire::SetExtendedAttributeMode { value } = out);
2952            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2953                SetExtendedAttributeMode::Set => 1,
2954
2955                SetExtendedAttributeMode::Create => 2,
2956
2957                SetExtendedAttributeMode::Replace => 3,
2958            }));
2959
2960            Ok(())
2961        }
2962    }
2963
2964    impl ::core::convert::From<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2965        fn from(wire: crate::wire::SetExtendedAttributeMode) -> Self {
2966            match u32::from(wire.value) {
2967                1 => Self::Set,
2968
2969                2 => Self::Create,
2970
2971                3 => Self::Replace,
2972
2973                _ => unsafe { ::core::hint::unreachable_unchecked() },
2974            }
2975        }
2976    }
2977
2978    impl ::fidl_next::FromWire<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2979        #[inline]
2980        fn from_wire(wire: crate::wire::SetExtendedAttributeMode) -> Self {
2981            Self::from(wire)
2982        }
2983    }
2984
2985    impl ::fidl_next::FromWireRef<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2986        #[inline]
2987        fn from_wire_ref(wire: &crate::wire::SetExtendedAttributeMode) -> Self {
2988            Self::from(*wire)
2989        }
2990    }
2991
2992    pub type NodeSetExtendedAttributeResponse = ();
2993
2994    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2995    pub struct NodeRemoveExtendedAttributeRequest {
2996        pub name: ::std::vec::Vec<u8>,
2997    }
2998
2999    unsafe impl<___E>
3000        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
3001        for NodeRemoveExtendedAttributeRequest
3002    where
3003        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3004        ___E: ::fidl_next::Encoder,
3005    {
3006        #[inline]
3007        fn encode(
3008            self,
3009            encoder_: &mut ___E,
3010            out_: &mut ::core::mem::MaybeUninit<
3011                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3012            >,
3013            _: (),
3014        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3015            ::fidl_next::munge! {
3016                let crate::wire::NodeRemoveExtendedAttributeRequest {
3017                    name,
3018
3019                } = out_;
3020            }
3021
3022            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
3023
3024            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3025            ::fidl_next::Constrained::validate(_field, (255, ()))?;
3026
3027            Ok(())
3028        }
3029    }
3030
3031    unsafe impl<'a, ___E>
3032        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
3033        for &'a NodeRemoveExtendedAttributeRequest
3034    where
3035        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3036        ___E: ::fidl_next::Encoder,
3037    {
3038        #[inline]
3039        fn encode(
3040            self,
3041            encoder_: &mut ___E,
3042            out_: &mut ::core::mem::MaybeUninit<
3043                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3044            >,
3045            _: (),
3046        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3047            ::fidl_next::munge! {
3048                let crate::wire::NodeRemoveExtendedAttributeRequest {
3049                    name,
3050
3051                } = out_;
3052            }
3053
3054            ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
3055
3056            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3057            ::fidl_next::Constrained::validate(_field, (255, ()))?;
3058
3059            Ok(())
3060        }
3061    }
3062
3063    unsafe impl<___E>
3064        ::fidl_next::EncodeOption<
3065            ::fidl_next::wire::Box<
3066                'static,
3067                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3068            >,
3069            ___E,
3070        > for NodeRemoveExtendedAttributeRequest
3071    where
3072        ___E: ::fidl_next::Encoder + ?Sized,
3073        NodeRemoveExtendedAttributeRequest:
3074            ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3075    {
3076        #[inline]
3077        fn encode_option(
3078            this: ::core::option::Option<Self>,
3079            encoder: &mut ___E,
3080            out: &mut ::core::mem::MaybeUninit<
3081                ::fidl_next::wire::Box<
3082                    'static,
3083                    crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3084                >,
3085            >,
3086            _: (),
3087        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3088            if let Some(inner) = this {
3089                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3090                ::fidl_next::wire::Box::encode_present(out);
3091            } else {
3092                ::fidl_next::wire::Box::encode_absent(out);
3093            }
3094
3095            Ok(())
3096        }
3097    }
3098
3099    unsafe impl<'a, ___E>
3100        ::fidl_next::EncodeOption<
3101            ::fidl_next::wire::Box<
3102                'static,
3103                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3104            >,
3105            ___E,
3106        > for &'a NodeRemoveExtendedAttributeRequest
3107    where
3108        ___E: ::fidl_next::Encoder + ?Sized,
3109        &'a NodeRemoveExtendedAttributeRequest:
3110            ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3111    {
3112        #[inline]
3113        fn encode_option(
3114            this: ::core::option::Option<Self>,
3115            encoder: &mut ___E,
3116            out: &mut ::core::mem::MaybeUninit<
3117                ::fidl_next::wire::Box<
3118                    'static,
3119                    crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3120                >,
3121            >,
3122            _: (),
3123        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3124            if let Some(inner) = this {
3125                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3126                ::fidl_next::wire::Box::encode_present(out);
3127            } else {
3128                ::fidl_next::wire::Box::encode_absent(out);
3129            }
3130
3131            Ok(())
3132        }
3133    }
3134
3135    impl<'de> ::fidl_next::FromWire<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3136        for NodeRemoveExtendedAttributeRequest
3137    {
3138        #[inline]
3139        fn from_wire(wire: crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3140            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
3141        }
3142    }
3143
3144    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3145        for NodeRemoveExtendedAttributeRequest
3146    {
3147        #[inline]
3148        fn from_wire_ref(wire: &crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3149            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
3150        }
3151    }
3152
3153    pub type NodeRemoveExtendedAttributeResponse = ();
3154
3155    pub type DirectoryCreateSymlinkResponse = ();
3156
3157    pub type NodeSetFlagsResponse = ();
3158
3159    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3160    pub struct NodeDeprecatedGetAttrResponse {
3161        pub s: ::fidl_next::fuchsia::zx::Status,
3162
3163        pub attributes: crate::natural::NodeAttributes,
3164    }
3165
3166    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
3167        for NodeDeprecatedGetAttrResponse
3168    where
3169        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3170    {
3171        #[inline]
3172        fn encode(
3173            self,
3174            encoder_: &mut ___E,
3175            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
3176            _: (),
3177        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3178            ::fidl_next::munge! {
3179                let crate::wire::NodeDeprecatedGetAttrResponse {
3180                    s,
3181                    attributes,
3182
3183                } = out_;
3184            }
3185
3186            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3187
3188            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3189
3190            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
3191
3192            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3193
3194            Ok(())
3195        }
3196    }
3197
3198    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
3199        for &'a NodeDeprecatedGetAttrResponse
3200    where
3201        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3202    {
3203        #[inline]
3204        fn encode(
3205            self,
3206            encoder_: &mut ___E,
3207            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
3208            _: (),
3209        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3210            ::fidl_next::munge! {
3211                let crate::wire::NodeDeprecatedGetAttrResponse {
3212                    s,
3213                    attributes,
3214
3215                } = out_;
3216            }
3217
3218            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3219
3220            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3221
3222            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
3223
3224            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3225
3226            Ok(())
3227        }
3228    }
3229
3230    unsafe impl<___E>
3231        ::fidl_next::EncodeOption<
3232            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3233            ___E,
3234        > for NodeDeprecatedGetAttrResponse
3235    where
3236        ___E: ::fidl_next::Encoder + ?Sized,
3237        NodeDeprecatedGetAttrResponse:
3238            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
3239    {
3240        #[inline]
3241        fn encode_option(
3242            this: ::core::option::Option<Self>,
3243            encoder: &mut ___E,
3244            out: &mut ::core::mem::MaybeUninit<
3245                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3246            >,
3247            _: (),
3248        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3249            if let Some(inner) = this {
3250                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3251                ::fidl_next::wire::Box::encode_present(out);
3252            } else {
3253                ::fidl_next::wire::Box::encode_absent(out);
3254            }
3255
3256            Ok(())
3257        }
3258    }
3259
3260    unsafe impl<'a, ___E>
3261        ::fidl_next::EncodeOption<
3262            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3263            ___E,
3264        > for &'a NodeDeprecatedGetAttrResponse
3265    where
3266        ___E: ::fidl_next::Encoder + ?Sized,
3267        &'a NodeDeprecatedGetAttrResponse:
3268            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
3269    {
3270        #[inline]
3271        fn encode_option(
3272            this: ::core::option::Option<Self>,
3273            encoder: &mut ___E,
3274            out: &mut ::core::mem::MaybeUninit<
3275                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3276            >,
3277            _: (),
3278        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3279            if let Some(inner) = this {
3280                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3281                ::fidl_next::wire::Box::encode_present(out);
3282            } else {
3283                ::fidl_next::wire::Box::encode_absent(out);
3284            }
3285
3286            Ok(())
3287        }
3288    }
3289
3290    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetAttrResponse>
3291        for NodeDeprecatedGetAttrResponse
3292    {
3293        #[inline]
3294        fn from_wire(wire: crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
3295            Self {
3296                s: ::fidl_next::FromWire::from_wire(wire.s),
3297
3298                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
3299            }
3300        }
3301    }
3302
3303    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetAttrResponse>
3304        for NodeDeprecatedGetAttrResponse
3305    {
3306        #[inline]
3307        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
3308            Self {
3309                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
3310
3311                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
3312            }
3313        }
3314    }
3315
3316    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3317    pub struct NodeDeprecatedSetAttrRequest {
3318        pub flags: crate::natural::NodeAttributeFlags,
3319
3320        pub attributes: crate::natural::NodeAttributes,
3321    }
3322
3323    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
3324        for NodeDeprecatedSetAttrRequest
3325    where
3326        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3327    {
3328        #[inline]
3329        fn encode(
3330            self,
3331            encoder_: &mut ___E,
3332            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
3333            _: (),
3334        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3335            ::fidl_next::munge! {
3336                let crate::wire::NodeDeprecatedSetAttrRequest {
3337                    flags,
3338                    attributes,
3339
3340                } = out_;
3341            }
3342
3343            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3344
3345            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3346
3347            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
3348
3349            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3350
3351            Ok(())
3352        }
3353    }
3354
3355    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
3356        for &'a NodeDeprecatedSetAttrRequest
3357    where
3358        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3359    {
3360        #[inline]
3361        fn encode(
3362            self,
3363            encoder_: &mut ___E,
3364            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
3365            _: (),
3366        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3367            ::fidl_next::munge! {
3368                let crate::wire::NodeDeprecatedSetAttrRequest {
3369                    flags,
3370                    attributes,
3371
3372                } = out_;
3373            }
3374
3375            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3376
3377            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3378
3379            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
3380
3381            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3382
3383            Ok(())
3384        }
3385    }
3386
3387    unsafe impl<___E>
3388        ::fidl_next::EncodeOption<
3389            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3390            ___E,
3391        > for NodeDeprecatedSetAttrRequest
3392    where
3393        ___E: ::fidl_next::Encoder + ?Sized,
3394        NodeDeprecatedSetAttrRequest:
3395            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
3396    {
3397        #[inline]
3398        fn encode_option(
3399            this: ::core::option::Option<Self>,
3400            encoder: &mut ___E,
3401            out: &mut ::core::mem::MaybeUninit<
3402                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3403            >,
3404            _: (),
3405        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3406            if let Some(inner) = this {
3407                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3408                ::fidl_next::wire::Box::encode_present(out);
3409            } else {
3410                ::fidl_next::wire::Box::encode_absent(out);
3411            }
3412
3413            Ok(())
3414        }
3415    }
3416
3417    unsafe impl<'a, ___E>
3418        ::fidl_next::EncodeOption<
3419            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3420            ___E,
3421        > for &'a NodeDeprecatedSetAttrRequest
3422    where
3423        ___E: ::fidl_next::Encoder + ?Sized,
3424        &'a NodeDeprecatedSetAttrRequest:
3425            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
3426    {
3427        #[inline]
3428        fn encode_option(
3429            this: ::core::option::Option<Self>,
3430            encoder: &mut ___E,
3431            out: &mut ::core::mem::MaybeUninit<
3432                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3433            >,
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::wire::Box::encode_present(out);
3439            } else {
3440                ::fidl_next::wire::Box::encode_absent(out);
3441            }
3442
3443            Ok(())
3444        }
3445    }
3446
3447    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrRequest>
3448        for NodeDeprecatedSetAttrRequest
3449    {
3450        #[inline]
3451        fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
3452            Self {
3453                flags: ::fidl_next::FromWire::from_wire(wire.flags),
3454
3455                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
3456            }
3457        }
3458    }
3459
3460    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrRequest>
3461        for NodeDeprecatedSetAttrRequest
3462    {
3463        #[inline]
3464        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
3465            Self {
3466                flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
3467
3468                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
3469            }
3470        }
3471    }
3472
3473    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3474    #[repr(C)]
3475    pub struct NodeDeprecatedSetAttrResponse {
3476        pub s: ::fidl_next::fuchsia::zx::Status,
3477    }
3478
3479    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
3480        for NodeDeprecatedSetAttrResponse
3481    where
3482        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3483    {
3484        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3485            Self,
3486            crate::wire::NodeDeprecatedSetAttrResponse,
3487        > = unsafe {
3488            ::fidl_next::CopyOptimization::enable_if(
3489                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
3490                    ::fidl_next::wire::fuchsia::Status,
3491                    ___E,
3492                >>::COPY_OPTIMIZATION
3493                    .is_enabled(),
3494            )
3495        };
3496
3497        #[inline]
3498        fn encode(
3499            self,
3500            encoder_: &mut ___E,
3501            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
3502            _: (),
3503        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3504            ::fidl_next::munge! {
3505                let crate::wire::NodeDeprecatedSetAttrResponse {
3506                    s,
3507
3508                } = out_;
3509            }
3510
3511            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3512
3513            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3514
3515            Ok(())
3516        }
3517    }
3518
3519    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
3520        for &'a NodeDeprecatedSetAttrResponse
3521    where
3522        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3523    {
3524        #[inline]
3525        fn encode(
3526            self,
3527            encoder_: &mut ___E,
3528            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
3529            _: (),
3530        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3531            ::fidl_next::munge! {
3532                let crate::wire::NodeDeprecatedSetAttrResponse {
3533                    s,
3534
3535                } = out_;
3536            }
3537
3538            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3539
3540            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3541
3542            Ok(())
3543        }
3544    }
3545
3546    unsafe impl<___E>
3547        ::fidl_next::EncodeOption<
3548            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3549            ___E,
3550        > for NodeDeprecatedSetAttrResponse
3551    where
3552        ___E: ::fidl_next::Encoder + ?Sized,
3553        NodeDeprecatedSetAttrResponse:
3554            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
3555    {
3556        #[inline]
3557        fn encode_option(
3558            this: ::core::option::Option<Self>,
3559            encoder: &mut ___E,
3560            out: &mut ::core::mem::MaybeUninit<
3561                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3562            >,
3563            _: (),
3564        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3565            if let Some(inner) = this {
3566                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3567                ::fidl_next::wire::Box::encode_present(out);
3568            } else {
3569                ::fidl_next::wire::Box::encode_absent(out);
3570            }
3571
3572            Ok(())
3573        }
3574    }
3575
3576    unsafe impl<'a, ___E>
3577        ::fidl_next::EncodeOption<
3578            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3579            ___E,
3580        > for &'a NodeDeprecatedSetAttrResponse
3581    where
3582        ___E: ::fidl_next::Encoder + ?Sized,
3583        &'a NodeDeprecatedSetAttrResponse:
3584            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
3585    {
3586        #[inline]
3587        fn encode_option(
3588            this: ::core::option::Option<Self>,
3589            encoder: &mut ___E,
3590            out: &mut ::core::mem::MaybeUninit<
3591                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3592            >,
3593            _: (),
3594        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3595            if let Some(inner) = this {
3596                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3597                ::fidl_next::wire::Box::encode_present(out);
3598            } else {
3599                ::fidl_next::wire::Box::encode_absent(out);
3600            }
3601
3602            Ok(())
3603        }
3604    }
3605
3606    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrResponse>
3607        for NodeDeprecatedSetAttrResponse
3608    {
3609        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3610            crate::wire::NodeDeprecatedSetAttrResponse,
3611            Self,
3612        > = unsafe {
3613            ::fidl_next::CopyOptimization::enable_if(
3614                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
3615                    ::fidl_next::wire::fuchsia::Status,
3616                >>::COPY_OPTIMIZATION
3617                    .is_enabled(),
3618            )
3619        };
3620
3621        #[inline]
3622        fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
3623            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
3624        }
3625    }
3626
3627    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrResponse>
3628        for NodeDeprecatedSetAttrResponse
3629    {
3630        #[inline]
3631        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
3632            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
3633        }
3634    }
3635
3636    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3637    #[repr(C)]
3638    pub struct NodeDeprecatedGetFlagsResponse {
3639        pub s: ::fidl_next::fuchsia::zx::Status,
3640
3641        pub flags: crate::natural::OpenFlags,
3642    }
3643
3644    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
3645        for NodeDeprecatedGetFlagsResponse
3646    where
3647        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3648    {
3649        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3650            Self,
3651            crate::wire::NodeDeprecatedGetFlagsResponse,
3652        > = unsafe {
3653            ::fidl_next::CopyOptimization::enable_if(
3654                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
3655                    ::fidl_next::wire::fuchsia::Status,
3656                    ___E,
3657                >>::COPY_OPTIMIZATION
3658                    .is_enabled()
3659                    && <crate::natural::OpenFlags as ::fidl_next::Encode<
3660                        crate::wire::OpenFlags,
3661                        ___E,
3662                    >>::COPY_OPTIMIZATION
3663                        .is_enabled(),
3664            )
3665        };
3666
3667        #[inline]
3668        fn encode(
3669            self,
3670            encoder_: &mut ___E,
3671            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
3672            _: (),
3673        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3674            ::fidl_next::munge! {
3675                let crate::wire::NodeDeprecatedGetFlagsResponse {
3676                    s,
3677                    flags,
3678
3679                } = out_;
3680            }
3681
3682            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3683
3684            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3685
3686            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3687
3688            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3689
3690            Ok(())
3691        }
3692    }
3693
3694    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
3695        for &'a NodeDeprecatedGetFlagsResponse
3696    where
3697        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3698    {
3699        #[inline]
3700        fn encode(
3701            self,
3702            encoder_: &mut ___E,
3703            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
3704            _: (),
3705        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3706            ::fidl_next::munge! {
3707                let crate::wire::NodeDeprecatedGetFlagsResponse {
3708                    s,
3709                    flags,
3710
3711                } = out_;
3712            }
3713
3714            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3715
3716            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3717
3718            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3719
3720            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3721
3722            Ok(())
3723        }
3724    }
3725
3726    unsafe impl<___E>
3727        ::fidl_next::EncodeOption<
3728            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3729            ___E,
3730        > for NodeDeprecatedGetFlagsResponse
3731    where
3732        ___E: ::fidl_next::Encoder + ?Sized,
3733        NodeDeprecatedGetFlagsResponse:
3734            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
3735    {
3736        #[inline]
3737        fn encode_option(
3738            this: ::core::option::Option<Self>,
3739            encoder: &mut ___E,
3740            out: &mut ::core::mem::MaybeUninit<
3741                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3742            >,
3743            _: (),
3744        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3745            if let Some(inner) = this {
3746                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3747                ::fidl_next::wire::Box::encode_present(out);
3748            } else {
3749                ::fidl_next::wire::Box::encode_absent(out);
3750            }
3751
3752            Ok(())
3753        }
3754    }
3755
3756    unsafe impl<'a, ___E>
3757        ::fidl_next::EncodeOption<
3758            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3759            ___E,
3760        > for &'a NodeDeprecatedGetFlagsResponse
3761    where
3762        ___E: ::fidl_next::Encoder + ?Sized,
3763        &'a NodeDeprecatedGetFlagsResponse:
3764            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
3765    {
3766        #[inline]
3767        fn encode_option(
3768            this: ::core::option::Option<Self>,
3769            encoder: &mut ___E,
3770            out: &mut ::core::mem::MaybeUninit<
3771                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3772            >,
3773            _: (),
3774        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3775            if let Some(inner) = this {
3776                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3777                ::fidl_next::wire::Box::encode_present(out);
3778            } else {
3779                ::fidl_next::wire::Box::encode_absent(out);
3780            }
3781
3782            Ok(())
3783        }
3784    }
3785
3786    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetFlagsResponse>
3787        for NodeDeprecatedGetFlagsResponse
3788    {
3789        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3790            crate::wire::NodeDeprecatedGetFlagsResponse,
3791            Self,
3792        > = unsafe {
3793            ::fidl_next::CopyOptimization::enable_if(
3794                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
3795                    ::fidl_next::wire::fuchsia::Status,
3796                >>::COPY_OPTIMIZATION
3797                    .is_enabled()
3798                    && <crate::natural::OpenFlags as ::fidl_next::FromWire<
3799                        crate::wire::OpenFlags,
3800                    >>::COPY_OPTIMIZATION
3801                        .is_enabled(),
3802            )
3803        };
3804
3805        #[inline]
3806        fn from_wire(wire: crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
3807            Self {
3808                s: ::fidl_next::FromWire::from_wire(wire.s),
3809
3810                flags: ::fidl_next::FromWire::from_wire(wire.flags),
3811            }
3812        }
3813    }
3814
3815    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetFlagsResponse>
3816        for NodeDeprecatedGetFlagsResponse
3817    {
3818        #[inline]
3819        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
3820            Self {
3821                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
3822
3823                flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
3824            }
3825        }
3826    }
3827
3828    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3829    #[repr(C)]
3830    pub struct NodeDeprecatedSetFlagsRequest {
3831        pub flags: crate::natural::OpenFlags,
3832    }
3833
3834    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
3835        for NodeDeprecatedSetFlagsRequest
3836    where
3837        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3838    {
3839        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3840            Self,
3841            crate::wire::NodeDeprecatedSetFlagsRequest,
3842        > = unsafe {
3843            ::fidl_next::CopyOptimization::enable_if(
3844                true && <crate::natural::OpenFlags as ::fidl_next::Encode<
3845                    crate::wire::OpenFlags,
3846                    ___E,
3847                >>::COPY_OPTIMIZATION
3848                    .is_enabled(),
3849            )
3850        };
3851
3852        #[inline]
3853        fn encode(
3854            self,
3855            encoder_: &mut ___E,
3856            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
3857            _: (),
3858        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3859            ::fidl_next::munge! {
3860                let crate::wire::NodeDeprecatedSetFlagsRequest {
3861                    flags,
3862
3863                } = out_;
3864            }
3865
3866            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3867
3868            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3869
3870            Ok(())
3871        }
3872    }
3873
3874    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
3875        for &'a NodeDeprecatedSetFlagsRequest
3876    where
3877        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3878    {
3879        #[inline]
3880        fn encode(
3881            self,
3882            encoder_: &mut ___E,
3883            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
3884            _: (),
3885        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3886            ::fidl_next::munge! {
3887                let crate::wire::NodeDeprecatedSetFlagsRequest {
3888                    flags,
3889
3890                } = out_;
3891            }
3892
3893            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3894
3895            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3896
3897            Ok(())
3898        }
3899    }
3900
3901    unsafe impl<___E>
3902        ::fidl_next::EncodeOption<
3903            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3904            ___E,
3905        > for NodeDeprecatedSetFlagsRequest
3906    where
3907        ___E: ::fidl_next::Encoder + ?Sized,
3908        NodeDeprecatedSetFlagsRequest:
3909            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
3910    {
3911        #[inline]
3912        fn encode_option(
3913            this: ::core::option::Option<Self>,
3914            encoder: &mut ___E,
3915            out: &mut ::core::mem::MaybeUninit<
3916                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3917            >,
3918            _: (),
3919        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3920            if let Some(inner) = this {
3921                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3922                ::fidl_next::wire::Box::encode_present(out);
3923            } else {
3924                ::fidl_next::wire::Box::encode_absent(out);
3925            }
3926
3927            Ok(())
3928        }
3929    }
3930
3931    unsafe impl<'a, ___E>
3932        ::fidl_next::EncodeOption<
3933            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3934            ___E,
3935        > for &'a NodeDeprecatedSetFlagsRequest
3936    where
3937        ___E: ::fidl_next::Encoder + ?Sized,
3938        &'a NodeDeprecatedSetFlagsRequest:
3939            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
3940    {
3941        #[inline]
3942        fn encode_option(
3943            this: ::core::option::Option<Self>,
3944            encoder: &mut ___E,
3945            out: &mut ::core::mem::MaybeUninit<
3946                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3947            >,
3948            _: (),
3949        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3950            if let Some(inner) = this {
3951                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3952                ::fidl_next::wire::Box::encode_present(out);
3953            } else {
3954                ::fidl_next::wire::Box::encode_absent(out);
3955            }
3956
3957            Ok(())
3958        }
3959    }
3960
3961    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsRequest>
3962        for NodeDeprecatedSetFlagsRequest
3963    {
3964        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3965            crate::wire::NodeDeprecatedSetFlagsRequest,
3966            Self,
3967        > = unsafe {
3968            ::fidl_next::CopyOptimization::enable_if(
3969                true && <crate::natural::OpenFlags as ::fidl_next::FromWire<
3970                    crate::wire::OpenFlags,
3971                >>::COPY_OPTIMIZATION
3972                    .is_enabled(),
3973            )
3974        };
3975
3976        #[inline]
3977        fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
3978            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
3979        }
3980    }
3981
3982    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsRequest>
3983        for NodeDeprecatedSetFlagsRequest
3984    {
3985        #[inline]
3986        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
3987            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
3988        }
3989    }
3990
3991    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3992    #[repr(C)]
3993    pub struct NodeDeprecatedSetFlagsResponse {
3994        pub s: ::fidl_next::fuchsia::zx::Status,
3995    }
3996
3997    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
3998        for NodeDeprecatedSetFlagsResponse
3999    where
4000        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4001    {
4002        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4003            Self,
4004            crate::wire::NodeDeprecatedSetFlagsResponse,
4005        > = unsafe {
4006            ::fidl_next::CopyOptimization::enable_if(
4007                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
4008                    ::fidl_next::wire::fuchsia::Status,
4009                    ___E,
4010                >>::COPY_OPTIMIZATION
4011                    .is_enabled(),
4012            )
4013        };
4014
4015        #[inline]
4016        fn encode(
4017            self,
4018            encoder_: &mut ___E,
4019            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
4020            _: (),
4021        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4022            ::fidl_next::munge! {
4023                let crate::wire::NodeDeprecatedSetFlagsResponse {
4024                    s,
4025
4026                } = out_;
4027            }
4028
4029            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4030
4031            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4032
4033            Ok(())
4034        }
4035    }
4036
4037    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
4038        for &'a NodeDeprecatedSetFlagsResponse
4039    where
4040        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4041    {
4042        #[inline]
4043        fn encode(
4044            self,
4045            encoder_: &mut ___E,
4046            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
4047            _: (),
4048        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4049            ::fidl_next::munge! {
4050                let crate::wire::NodeDeprecatedSetFlagsResponse {
4051                    s,
4052
4053                } = out_;
4054            }
4055
4056            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
4057
4058            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4059
4060            Ok(())
4061        }
4062    }
4063
4064    unsafe impl<___E>
4065        ::fidl_next::EncodeOption<
4066            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4067            ___E,
4068        > for NodeDeprecatedSetFlagsResponse
4069    where
4070        ___E: ::fidl_next::Encoder + ?Sized,
4071        NodeDeprecatedSetFlagsResponse:
4072            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
4073    {
4074        #[inline]
4075        fn encode_option(
4076            this: ::core::option::Option<Self>,
4077            encoder: &mut ___E,
4078            out: &mut ::core::mem::MaybeUninit<
4079                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4080            >,
4081            _: (),
4082        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4083            if let Some(inner) = this {
4084                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4085                ::fidl_next::wire::Box::encode_present(out);
4086            } else {
4087                ::fidl_next::wire::Box::encode_absent(out);
4088            }
4089
4090            Ok(())
4091        }
4092    }
4093
4094    unsafe impl<'a, ___E>
4095        ::fidl_next::EncodeOption<
4096            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4097            ___E,
4098        > for &'a NodeDeprecatedSetFlagsResponse
4099    where
4100        ___E: ::fidl_next::Encoder + ?Sized,
4101        &'a NodeDeprecatedSetFlagsResponse:
4102            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
4103    {
4104        #[inline]
4105        fn encode_option(
4106            this: ::core::option::Option<Self>,
4107            encoder: &mut ___E,
4108            out: &mut ::core::mem::MaybeUninit<
4109                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4110            >,
4111            _: (),
4112        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4113            if let Some(inner) = this {
4114                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4115                ::fidl_next::wire::Box::encode_present(out);
4116            } else {
4117                ::fidl_next::wire::Box::encode_absent(out);
4118            }
4119
4120            Ok(())
4121        }
4122    }
4123
4124    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsResponse>
4125        for NodeDeprecatedSetFlagsResponse
4126    {
4127        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4128            crate::wire::NodeDeprecatedSetFlagsResponse,
4129            Self,
4130        > = unsafe {
4131            ::fidl_next::CopyOptimization::enable_if(
4132                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
4133                    ::fidl_next::wire::fuchsia::Status,
4134                >>::COPY_OPTIMIZATION
4135                    .is_enabled(),
4136            )
4137        };
4138
4139        #[inline]
4140        fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
4141            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
4142        }
4143    }
4144
4145    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsResponse>
4146        for NodeDeprecatedSetFlagsResponse
4147    {
4148        #[inline]
4149        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
4150            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
4151        }
4152    }
4153
4154    ::fidl_next::bitflags::bitflags! {
4155        #[doc = " Flags used to specify how a node should be opened. Note that ranges of bits are reserved\n for specific use cases:\n  * Bits  1-16: Permission flags `PERM_*` (e.g. [`Flags.PERM_READ_BYTES`]).\n  * Bits 17-32: POSIX compatibile `O_*` flags (e.g. [`Flags.FILE_TRUNCATE`] or `O_TRUNC`).\n  * Bits 33-64: Fuchsia-specific flags.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct Flags: u64 {
4156            #[doc = " Allows opening child nodes with [`PROTOCOL_SERVICE`].\n"]const PERM_CONNECT = 1;
4157            #[doc = " Read byte contents of a file.\n"]const PERM_READ_BYTES = 2;
4158            #[doc = " Write byte contents to a file.\n"]const PERM_WRITE_BYTES = 4;
4159            #[doc = " Execute byte contents of a file.\n"]const PERM_EXECUTE = 8;
4160            #[doc = " Get/query attributes of a node.\n"]const PERM_GET_ATTRIBUTES = 16;
4161            #[doc = " Set/update attributes of a node.\n"]const PERM_UPDATE_ATTRIBUTES = 32;
4162            #[doc = " Enumerate (list) directory entries.\n"]const PERM_ENUMERATE = 64;
4163            #[doc = " Allow opening a child node with a node protocol. Must be specified with PERM_ENUMERATE\n otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PERM_TRAVERSE = 128;
4164            #[doc = " Modify directory entries (create/rename/link/unlink). Must be specified with\n PERM_ENUMERATE otherwise requests will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PERM_MODIFY_DIRECTORY = 256;
4165            #[doc = " Inherit write permissions when available (PERM_WRITE_BYTES, PERM_UPDATE_ATTRIBUTES,\n PERM_MODIFY_DIRECTORY, /// PERM_ENUMERATE). Servers must ensure this flag is removed\n if the parent connection lacks any of these rights. See [`INHERITED_WRITE_PERMISSIONS`]\n for the exact set of permissions that will be inherited.\n"]const PERM_INHERIT_WRITE = 8192;
4166            #[doc = " Inherit execute permission when available (PERM_EXECUTE).\n Servers must ensure this flag is removed if the parent connection lacks PERM_EXECUTE.\n"]const PERM_INHERIT_EXECUTE = 16384;
4167            #[doc = " Connect to the underlying protocol if this is a service node. The caller must determine the\n correct protocol to use (e.g. based on path). Unless used with [`PROTOCOL_NODE`], specifying\n other flags with the request will fail with `ZX_ERR_INVALID_ARGS`.\n"]const PROTOCOL_SERVICE = 4294967296;
4168            #[doc = " Connect to the underlying node. Takes precedence over other protocols. If other `PROTOCOL_*`\n are specified, they will be used to validate the target node type. Requests will fail with\n `ZX_ERR_INVALID_ARGS` if flags other than `PROTOCOL_*` and [`FLAG_SEND_REPRESENTATION`] are\n specified. Equivalent to POSIX `O_PATH`.\n"]const PROTOCOL_NODE = 4194304;
4169            #[doc = " Caller accepts [`fuchsia.io/Directory`] protocol. Equivalent to POSIX `O_DIRECTORY`.\n"]const PROTOCOL_DIRECTORY = 524288;
4170            #[doc = " Caller accepts [`fuchsia.io/File`] protocol.\n"]const PROTOCOL_FILE = 8589934592;
4171            #[doc = " Caller accepts [`fuchsia.io/Symlink`] protocol.\n"]const PROTOCOL_SYMLINK = 17179869184;
4172            #[doc = " Caller requests a [`fuchsia.io/Node.OnRepresentation`] event on success.\n"]const FLAG_SEND_REPRESENTATION = 1099511627776;
4173            #[doc = " Create a new object if one doesn\'t exist, otherwise open an existing object. If set, a\n single `PROTOCOL_*` flag must be set indicating the type of object to create. Equivalent\n to POSIX `O_CREAT`.\n"]const FLAG_MAYBE_CREATE = 65536;
4174            #[doc = " Create a new object if one doesn\'t exist, otherwise fail the request with\n `ZX_ERR_ALREADY_EXISTS`. If set, a single `PROTOCOL_*` flag must be set indicating the type\n of object to create. Takes precedence over [`FLAG_MAYBE_CREATE`]. Equivalent to POSIX\n `O_EXCL`.\n"]const FLAG_MUST_CREATE = 131072;
4175            #[doc = " Create a new unnamed temporary object. The object is temporary until it is linked to the\n filesystem. If specified with `FLAG_TEMPORARY_AS_NOT_LINKABLE`, then the created object is\n not linkable. If this flag is set:\n  * `path` specified in [`fuchsia.io/Directory.Open`] refers to the path of the directory\n    which the new object will be created in,\n  * A `PROTOCOL_*` flag is set to indicate the type of object to be created. Currently, this\n    is only supported when specified with `PROTOCOL_FILE`, in which case, it is equivalent\n    to Linux `O_TMPFILE`.\n  * `FLAG_MAYBE_CREATE` will be ignored.\n"]const FLAG_CREATE_AS_UNNAMED_TEMPORARY = 34359738368;
4176            #[doc = " Open the file in append mode. The seek pointer will be moved to end-of-file (EOF)\n before all writes. Equivalent to POSIX `O_APPEND`.\n"]const FILE_APPEND = 1048576;
4177            #[doc = " Truncate the file to zero length upon opening it. Equivalent to POSIX `O_TRUNC`.\n"]const FILE_TRUNCATE = 262144;
4178            const _ = !0;
4179        }
4180    }
4181
4182    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for Flags
4183    where
4184        ___E: ?Sized,
4185    {
4186        #[inline]
4187        fn encode(
4188            self,
4189            encoder: &mut ___E,
4190            out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
4191            _: (),
4192        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4193            ::fidl_next::Encode::encode(&self, encoder, out, ())
4194        }
4195    }
4196
4197    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for &'a Flags
4198    where
4199        ___E: ?Sized,
4200    {
4201        #[inline]
4202        fn encode(
4203            self,
4204            _: &mut ___E,
4205            out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
4206            _: (),
4207        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4208            ::fidl_next::munge!(let crate::wire::Flags { value } = out);
4209
4210            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
4211            Ok(())
4212        }
4213    }
4214
4215    impl ::core::convert::From<crate::wire::Flags> for Flags {
4216        fn from(wire: crate::wire::Flags) -> Self {
4217            Self::from_bits_retain(u64::from(wire.value))
4218        }
4219    }
4220
4221    impl ::fidl_next::FromWire<crate::wire::Flags> for Flags {
4222        #[inline]
4223        fn from_wire(wire: crate::wire::Flags) -> Self {
4224            Self::from(wire)
4225        }
4226    }
4227
4228    impl ::fidl_next::FromWireRef<crate::wire::Flags> for Flags {
4229        #[inline]
4230        fn from_wire_ref(wire: &crate::wire::Flags) -> Self {
4231            Self::from(*wire)
4232        }
4233    }
4234
4235    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4236    #[repr(C)]
4237    pub struct NodeGetFlagsResponse {
4238        pub flags: crate::natural::Flags,
4239    }
4240
4241    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
4242        for NodeGetFlagsResponse
4243    where
4244        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4245    {
4246        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4247            Self,
4248            crate::wire::NodeGetFlagsResponse,
4249        > = unsafe {
4250            ::fidl_next::CopyOptimization::enable_if(
4251            true
4252
4253                && <
4254                    crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
4255                >::COPY_OPTIMIZATION.is_enabled()
4256
4257        )
4258        };
4259
4260        #[inline]
4261        fn encode(
4262            self,
4263            encoder_: &mut ___E,
4264            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
4265            _: (),
4266        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4267            ::fidl_next::munge! {
4268                let crate::wire::NodeGetFlagsResponse {
4269                    flags,
4270
4271                } = out_;
4272            }
4273
4274            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4275
4276            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4277
4278            Ok(())
4279        }
4280    }
4281
4282    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
4283        for &'a NodeGetFlagsResponse
4284    where
4285        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4286    {
4287        #[inline]
4288        fn encode(
4289            self,
4290            encoder_: &mut ___E,
4291            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
4292            _: (),
4293        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4294            ::fidl_next::munge! {
4295                let crate::wire::NodeGetFlagsResponse {
4296                    flags,
4297
4298                } = out_;
4299            }
4300
4301            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4302
4303            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4304
4305            Ok(())
4306        }
4307    }
4308
4309    unsafe impl<___E>
4310        ::fidl_next::EncodeOption<
4311            ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4312            ___E,
4313        > for NodeGetFlagsResponse
4314    where
4315        ___E: ::fidl_next::Encoder + ?Sized,
4316        NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
4317    {
4318        #[inline]
4319        fn encode_option(
4320            this: ::core::option::Option<Self>,
4321            encoder: &mut ___E,
4322            out: &mut ::core::mem::MaybeUninit<
4323                ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4324            >,
4325            _: (),
4326        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4327            if let Some(inner) = this {
4328                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4329                ::fidl_next::wire::Box::encode_present(out);
4330            } else {
4331                ::fidl_next::wire::Box::encode_absent(out);
4332            }
4333
4334            Ok(())
4335        }
4336    }
4337
4338    unsafe impl<'a, ___E>
4339        ::fidl_next::EncodeOption<
4340            ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4341            ___E,
4342        > for &'a NodeGetFlagsResponse
4343    where
4344        ___E: ::fidl_next::Encoder + ?Sized,
4345        &'a NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
4346    {
4347        #[inline]
4348        fn encode_option(
4349            this: ::core::option::Option<Self>,
4350            encoder: &mut ___E,
4351            out: &mut ::core::mem::MaybeUninit<
4352                ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4353            >,
4354            _: (),
4355        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4356            if let Some(inner) = this {
4357                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4358                ::fidl_next::wire::Box::encode_present(out);
4359            } else {
4360                ::fidl_next::wire::Box::encode_absent(out);
4361            }
4362
4363            Ok(())
4364        }
4365    }
4366
4367    impl ::fidl_next::FromWire<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
4368        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4369            crate::wire::NodeGetFlagsResponse,
4370            Self,
4371        > = unsafe {
4372            ::fidl_next::CopyOptimization::enable_if(
4373            true
4374
4375                && <
4376                    crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
4377                >::COPY_OPTIMIZATION.is_enabled()
4378
4379        )
4380        };
4381
4382        #[inline]
4383        fn from_wire(wire: crate::wire::NodeGetFlagsResponse) -> Self {
4384            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
4385        }
4386    }
4387
4388    impl ::fidl_next::FromWireRef<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
4389        #[inline]
4390        fn from_wire_ref(wire: &crate::wire::NodeGetFlagsResponse) -> Self {
4391            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
4392        }
4393    }
4394
4395    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4396    #[repr(C)]
4397    pub struct NodeSetFlagsRequest {
4398        pub flags: crate::natural::Flags,
4399    }
4400
4401    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
4402        for NodeSetFlagsRequest
4403    where
4404        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4405    {
4406        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4407            Self,
4408            crate::wire::NodeSetFlagsRequest,
4409        > = unsafe {
4410            ::fidl_next::CopyOptimization::enable_if(
4411            true
4412
4413                && <
4414                    crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
4415                >::COPY_OPTIMIZATION.is_enabled()
4416
4417        )
4418        };
4419
4420        #[inline]
4421        fn encode(
4422            self,
4423            encoder_: &mut ___E,
4424            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
4425            _: (),
4426        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4427            ::fidl_next::munge! {
4428                let crate::wire::NodeSetFlagsRequest {
4429                    flags,
4430
4431                } = out_;
4432            }
4433
4434            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4435
4436            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4437
4438            Ok(())
4439        }
4440    }
4441
4442    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
4443        for &'a NodeSetFlagsRequest
4444    where
4445        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4446    {
4447        #[inline]
4448        fn encode(
4449            self,
4450            encoder_: &mut ___E,
4451            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
4452            _: (),
4453        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4454            ::fidl_next::munge! {
4455                let crate::wire::NodeSetFlagsRequest {
4456                    flags,
4457
4458                } = out_;
4459            }
4460
4461            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4462
4463            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4464
4465            Ok(())
4466        }
4467    }
4468
4469    unsafe impl<___E>
4470        ::fidl_next::EncodeOption<
4471            ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4472            ___E,
4473        > for NodeSetFlagsRequest
4474    where
4475        ___E: ::fidl_next::Encoder + ?Sized,
4476        NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
4477    {
4478        #[inline]
4479        fn encode_option(
4480            this: ::core::option::Option<Self>,
4481            encoder: &mut ___E,
4482            out: &mut ::core::mem::MaybeUninit<
4483                ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4484            >,
4485            _: (),
4486        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4487            if let Some(inner) = this {
4488                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4489                ::fidl_next::wire::Box::encode_present(out);
4490            } else {
4491                ::fidl_next::wire::Box::encode_absent(out);
4492            }
4493
4494            Ok(())
4495        }
4496    }
4497
4498    unsafe impl<'a, ___E>
4499        ::fidl_next::EncodeOption<
4500            ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4501            ___E,
4502        > for &'a NodeSetFlagsRequest
4503    where
4504        ___E: ::fidl_next::Encoder + ?Sized,
4505        &'a NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
4506    {
4507        #[inline]
4508        fn encode_option(
4509            this: ::core::option::Option<Self>,
4510            encoder: &mut ___E,
4511            out: &mut ::core::mem::MaybeUninit<
4512                ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4513            >,
4514            _: (),
4515        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4516            if let Some(inner) = this {
4517                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4518                ::fidl_next::wire::Box::encode_present(out);
4519            } else {
4520                ::fidl_next::wire::Box::encode_absent(out);
4521            }
4522
4523            Ok(())
4524        }
4525    }
4526
4527    impl ::fidl_next::FromWire<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
4528        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4529            crate::wire::NodeSetFlagsRequest,
4530            Self,
4531        > = unsafe {
4532            ::fidl_next::CopyOptimization::enable_if(
4533            true
4534
4535                && <
4536                    crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
4537                >::COPY_OPTIMIZATION.is_enabled()
4538
4539        )
4540        };
4541
4542        #[inline]
4543        fn from_wire(wire: crate::wire::NodeSetFlagsRequest) -> Self {
4544            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
4545        }
4546    }
4547
4548    impl ::fidl_next::FromWireRef<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
4549        #[inline]
4550        fn from_wire_ref(wire: &crate::wire::NodeSetFlagsRequest) -> Self {
4551            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
4552        }
4553    }
4554
4555    #[doc = " Used in places where empty structs are needed, such as empty union members, to avoid creating\n new struct types.\n"]
4556    pub type EmptyStruct = ();
4557
4558    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4559    pub enum SelinuxContext {
4560        Data(::std::vec::Vec<u8>),
4561
4562        UseExtendedAttributes(crate::natural::EmptyStruct),
4563
4564        UnknownOrdinal_(u64),
4565    }
4566
4567    impl SelinuxContext {
4568        pub fn is_unknown(&self) -> bool {
4569            #[allow(unreachable_patterns)]
4570            match self {
4571                Self::UnknownOrdinal_(_) => true,
4572                _ => false,
4573            }
4574        }
4575    }
4576
4577    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E> for SelinuxContext
4578    where
4579        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4580        ___E: ::fidl_next::Encoder,
4581    {
4582        #[inline]
4583        fn encode(
4584            self,
4585            encoder: &mut ___E,
4586            out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
4587            _: (),
4588        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4589            ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
4590
4591            match self {
4592                Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
4593                    ___E,
4594                    ::fidl_next::wire::Vector<'static, u8>,
4595                >(value, 1, encoder, raw, (256, ()))?,
4596
4597                Self::UseExtendedAttributes(value) => ::fidl_next::wire::Union::encode_as::<
4598                    ___E,
4599                    crate::wire::EmptyStruct,
4600                >(value, 2, encoder, raw, ())?,
4601
4602                Self::UnknownOrdinal_(ordinal) => {
4603                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
4604                }
4605            }
4606
4607            Ok(())
4608        }
4609    }
4610
4611    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>
4612        for &'a SelinuxContext
4613    where
4614        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4615        ___E: ::fidl_next::Encoder,
4616    {
4617        #[inline]
4618        fn encode(
4619            self,
4620            encoder: &mut ___E,
4621            out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
4622            _: (),
4623        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4624            ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
4625
4626            match self {
4627                SelinuxContext::Data(value) => ::fidl_next::wire::Union::encode_as::<
4628                    ___E,
4629                    ::fidl_next::wire::Vector<'static, u8>,
4630                >(value, 1, encoder, raw, (256, ()))?,
4631
4632                SelinuxContext::UseExtendedAttributes(value) => {
4633                    ::fidl_next::wire::Union::encode_as::<___E, crate::wire::EmptyStruct>(
4634                        value,
4635                        2,
4636                        encoder,
4637                        raw,
4638                        (),
4639                    )?
4640                }
4641
4642                SelinuxContext::UnknownOrdinal_(ordinal) => {
4643                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
4644                }
4645            }
4646
4647            Ok(())
4648        }
4649    }
4650
4651    unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
4652        for SelinuxContext
4653    where
4654        ___E: ?Sized,
4655        SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
4656    {
4657        #[inline]
4658        fn encode_option(
4659            this: ::core::option::Option<Self>,
4660            encoder: &mut ___E,
4661            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
4662            _: (),
4663        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4664            ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
4665
4666            if let Some(inner) = this {
4667                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4668                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4669            } else {
4670                ::fidl_next::wire::Union::encode_absent(raw);
4671            }
4672
4673            Ok(())
4674        }
4675    }
4676
4677    unsafe impl<'a, ___E>
4678        ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
4679        for &'a SelinuxContext
4680    where
4681        ___E: ?Sized,
4682        &'a SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
4683    {
4684        #[inline]
4685        fn encode_option(
4686            this: ::core::option::Option<Self>,
4687            encoder: &mut ___E,
4688            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
4689            _: (),
4690        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4691            ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
4692
4693            if let Some(inner) = this {
4694                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4695                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4696            } else {
4697                ::fidl_next::wire::Union::encode_absent(raw);
4698            }
4699
4700            Ok(())
4701        }
4702    }
4703
4704    impl<'de> ::fidl_next::FromWire<crate::wire::SelinuxContext<'de>> for SelinuxContext {
4705        #[inline]
4706        fn from_wire(wire: crate::wire::SelinuxContext<'de>) -> Self {
4707            let wire = ::core::mem::ManuallyDrop::new(wire);
4708            match wire.raw.ordinal() {
4709                1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
4710                    wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
4711                })),
4712
4713                2 => Self::UseExtendedAttributes(::fidl_next::FromWire::from_wire(unsafe {
4714                    wire.raw.get().read_unchecked::<crate::wire::EmptyStruct>()
4715                })),
4716
4717                ord => return Self::UnknownOrdinal_(ord as u64),
4718            }
4719        }
4720    }
4721
4722    impl<'de> ::fidl_next::FromWireRef<crate::wire::SelinuxContext<'de>> for SelinuxContext {
4723        #[inline]
4724        fn from_wire_ref(wire: &crate::wire::SelinuxContext<'de>) -> Self {
4725            match wire.raw.ordinal() {
4726                1 => Self::Data(::fidl_next::FromWireRef::from_wire_ref(unsafe {
4727                    wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
4728                })),
4729
4730                2 => Self::UseExtendedAttributes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
4731                    wire.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
4732                })),
4733
4734                ord => return Self::UnknownOrdinal_(ord as u64),
4735            }
4736        }
4737    }
4738
4739    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
4740        for SelinuxContext
4741    {
4742        #[inline]
4743        fn from_wire_option(
4744            wire: crate::wire_optional::SelinuxContext<'de>,
4745        ) -> ::core::option::Option<Self> {
4746            if let Some(inner) = wire.into_option() {
4747                Some(::fidl_next::FromWire::from_wire(inner))
4748            } else {
4749                None
4750            }
4751        }
4752    }
4753
4754    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
4755        for Box<SelinuxContext>
4756    {
4757        #[inline]
4758        fn from_wire_option(
4759            wire: crate::wire_optional::SelinuxContext<'de>,
4760        ) -> ::core::option::Option<Self> {
4761            <SelinuxContext as ::fidl_next::FromWireOption<
4762                crate::wire_optional::SelinuxContext<'de>,
4763            >>::from_wire_option(wire)
4764            .map(Box::new)
4765        }
4766    }
4767
4768    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::SelinuxContext<'de>>
4769        for Box<SelinuxContext>
4770    {
4771        #[inline]
4772        fn from_wire_option_ref(
4773            wire: &crate::wire_optional::SelinuxContext<'de>,
4774        ) -> ::core::option::Option<Self> {
4775            if let Some(inner) = wire.as_ref() {
4776                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
4777            } else {
4778                None
4779            }
4780        }
4781    }
4782
4783    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4784    pub struct MutableNodeAttributes {
4785        pub creation_time: ::core::option::Option<u64>,
4786
4787        pub modification_time: ::core::option::Option<u64>,
4788
4789        pub mode: ::core::option::Option<u32>,
4790
4791        pub uid: ::core::option::Option<u32>,
4792
4793        pub gid: ::core::option::Option<u32>,
4794
4795        pub rdev: ::core::option::Option<u64>,
4796
4797        pub access_time: ::core::option::Option<u64>,
4798
4799        pub casefold: ::core::option::Option<bool>,
4800
4801        pub selinux_context: ::core::option::Option<crate::natural::SelinuxContext>,
4802
4803        pub wrapping_key_id: ::core::option::Option<[u8; 16]>,
4804    }
4805
4806    impl MutableNodeAttributes {
4807        fn __max_ordinal(&self) -> usize {
4808            if self.wrapping_key_id.is_some() {
4809                return 10;
4810            }
4811
4812            if self.selinux_context.is_some() {
4813                return 9;
4814            }
4815
4816            if self.casefold.is_some() {
4817                return 8;
4818            }
4819
4820            if self.access_time.is_some() {
4821                return 7;
4822            }
4823
4824            if self.rdev.is_some() {
4825                return 6;
4826            }
4827
4828            if self.gid.is_some() {
4829                return 5;
4830            }
4831
4832            if self.uid.is_some() {
4833                return 4;
4834            }
4835
4836            if self.mode.is_some() {
4837                return 3;
4838            }
4839
4840            if self.modification_time.is_some() {
4841                return 2;
4842            }
4843
4844            if self.creation_time.is_some() {
4845                return 1;
4846            }
4847
4848            0
4849        }
4850    }
4851
4852    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
4853        for MutableNodeAttributes
4854    where
4855        ___E: ::fidl_next::Encoder + ?Sized,
4856    {
4857        #[inline]
4858        fn encode(
4859            mut self,
4860            encoder: &mut ___E,
4861            out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
4862            _: (),
4863        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4864            ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
4865
4866            let max_ord = self.__max_ordinal();
4867
4868            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
4869            ::fidl_next::Wire::zero_padding(&mut out);
4870
4871            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
4872                ::fidl_next::wire::Envelope,
4873            >(encoder, max_ord);
4874
4875            for i in 1..=max_ord {
4876                match i {
4877                    10 => {
4878                        if let Some(value) = self.wrapping_key_id.take() {
4879                            ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
4880                                value,
4881                                preallocated.encoder,
4882                                &mut out,
4883                                (),
4884                            )?;
4885                        } else {
4886                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4887                        }
4888                    }
4889
4890                    9 => {
4891                        if let Some(value) = self.selinux_context.take() {
4892                            ::fidl_next::wire::Envelope::encode_value::<
4893                                crate::wire::SelinuxContext<'static>,
4894                                ___E,
4895                            >(
4896                                value, preallocated.encoder, &mut out, ()
4897                            )?;
4898                        } else {
4899                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4900                        }
4901                    }
4902
4903                    8 => {
4904                        if let Some(value) = self.casefold.take() {
4905                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
4906                                value,
4907                                preallocated.encoder,
4908                                &mut out,
4909                                (),
4910                            )?;
4911                        } else {
4912                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4913                        }
4914                    }
4915
4916                    7 => {
4917                        if let Some(value) = self.access_time.take() {
4918                            ::fidl_next::wire::Envelope::encode_value::<
4919                                ::fidl_next::wire::Uint64,
4920                                ___E,
4921                            >(
4922                                value, preallocated.encoder, &mut out, ()
4923                            )?;
4924                        } else {
4925                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4926                        }
4927                    }
4928
4929                    6 => {
4930                        if let Some(value) = self.rdev.take() {
4931                            ::fidl_next::wire::Envelope::encode_value::<
4932                                ::fidl_next::wire::Uint64,
4933                                ___E,
4934                            >(
4935                                value, preallocated.encoder, &mut out, ()
4936                            )?;
4937                        } else {
4938                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4939                        }
4940                    }
4941
4942                    5 => {
4943                        if let Some(value) = self.gid.take() {
4944                            ::fidl_next::wire::Envelope::encode_value::<
4945                                ::fidl_next::wire::Uint32,
4946                                ___E,
4947                            >(
4948                                value, preallocated.encoder, &mut out, ()
4949                            )?;
4950                        } else {
4951                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4952                        }
4953                    }
4954
4955                    4 => {
4956                        if let Some(value) = self.uid.take() {
4957                            ::fidl_next::wire::Envelope::encode_value::<
4958                                ::fidl_next::wire::Uint32,
4959                                ___E,
4960                            >(
4961                                value, preallocated.encoder, &mut out, ()
4962                            )?;
4963                        } else {
4964                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4965                        }
4966                    }
4967
4968                    3 => {
4969                        if let Some(value) = self.mode.take() {
4970                            ::fidl_next::wire::Envelope::encode_value::<
4971                                ::fidl_next::wire::Uint32,
4972                                ___E,
4973                            >(
4974                                value, preallocated.encoder, &mut out, ()
4975                            )?;
4976                        } else {
4977                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4978                        }
4979                    }
4980
4981                    2 => {
4982                        if let Some(value) = self.modification_time.take() {
4983                            ::fidl_next::wire::Envelope::encode_value::<
4984                                ::fidl_next::wire::Uint64,
4985                                ___E,
4986                            >(
4987                                value, preallocated.encoder, &mut out, ()
4988                            )?;
4989                        } else {
4990                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4991                        }
4992                    }
4993
4994                    1 => {
4995                        if let Some(value) = self.creation_time.take() {
4996                            ::fidl_next::wire::Envelope::encode_value::<
4997                                ::fidl_next::wire::Uint64,
4998                                ___E,
4999                            >(
5000                                value, preallocated.encoder, &mut out, ()
5001                            )?;
5002                        } else {
5003                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5004                        }
5005                    }
5006
5007                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5008                }
5009                unsafe {
5010                    preallocated.write_next(out.assume_init_ref());
5011                }
5012            }
5013
5014            ::fidl_next::wire::Table::encode_len(table, max_ord);
5015
5016            Ok(())
5017        }
5018    }
5019
5020    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
5021        for &'a MutableNodeAttributes
5022    where
5023        ___E: ::fidl_next::Encoder + ?Sized,
5024    {
5025        #[inline]
5026        fn encode(
5027            self,
5028            encoder: &mut ___E,
5029            out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
5030            _: (),
5031        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5032            ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
5033
5034            let max_ord = self.__max_ordinal();
5035
5036            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5037            ::fidl_next::Wire::zero_padding(&mut out);
5038
5039            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5040                ::fidl_next::wire::Envelope,
5041            >(encoder, max_ord);
5042
5043            for i in 1..=max_ord {
5044                match i {
5045                    10 => {
5046                        if let Some(value) = &self.wrapping_key_id {
5047                            ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
5048                                value,
5049                                preallocated.encoder,
5050                                &mut out,
5051                                (),
5052                            )?;
5053                        } else {
5054                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5055                        }
5056                    }
5057
5058                    9 => {
5059                        if let Some(value) = &self.selinux_context {
5060                            ::fidl_next::wire::Envelope::encode_value::<
5061                                crate::wire::SelinuxContext<'static>,
5062                                ___E,
5063                            >(
5064                                value, preallocated.encoder, &mut out, ()
5065                            )?;
5066                        } else {
5067                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5068                        }
5069                    }
5070
5071                    8 => {
5072                        if let Some(value) = &self.casefold {
5073                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5074                                value,
5075                                preallocated.encoder,
5076                                &mut out,
5077                                (),
5078                            )?;
5079                        } else {
5080                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5081                        }
5082                    }
5083
5084                    7 => {
5085                        if let Some(value) = &self.access_time {
5086                            ::fidl_next::wire::Envelope::encode_value::<
5087                                ::fidl_next::wire::Uint64,
5088                                ___E,
5089                            >(
5090                                value, preallocated.encoder, &mut out, ()
5091                            )?;
5092                        } else {
5093                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5094                        }
5095                    }
5096
5097                    6 => {
5098                        if let Some(value) = &self.rdev {
5099                            ::fidl_next::wire::Envelope::encode_value::<
5100                                ::fidl_next::wire::Uint64,
5101                                ___E,
5102                            >(
5103                                value, preallocated.encoder, &mut out, ()
5104                            )?;
5105                        } else {
5106                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5107                        }
5108                    }
5109
5110                    5 => {
5111                        if let Some(value) = &self.gid {
5112                            ::fidl_next::wire::Envelope::encode_value::<
5113                                ::fidl_next::wire::Uint32,
5114                                ___E,
5115                            >(
5116                                value, preallocated.encoder, &mut out, ()
5117                            )?;
5118                        } else {
5119                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5120                        }
5121                    }
5122
5123                    4 => {
5124                        if let Some(value) = &self.uid {
5125                            ::fidl_next::wire::Envelope::encode_value::<
5126                                ::fidl_next::wire::Uint32,
5127                                ___E,
5128                            >(
5129                                value, preallocated.encoder, &mut out, ()
5130                            )?;
5131                        } else {
5132                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5133                        }
5134                    }
5135
5136                    3 => {
5137                        if let Some(value) = &self.mode {
5138                            ::fidl_next::wire::Envelope::encode_value::<
5139                                ::fidl_next::wire::Uint32,
5140                                ___E,
5141                            >(
5142                                value, preallocated.encoder, &mut out, ()
5143                            )?;
5144                        } else {
5145                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5146                        }
5147                    }
5148
5149                    2 => {
5150                        if let Some(value) = &self.modification_time {
5151                            ::fidl_next::wire::Envelope::encode_value::<
5152                                ::fidl_next::wire::Uint64,
5153                                ___E,
5154                            >(
5155                                value, preallocated.encoder, &mut out, ()
5156                            )?;
5157                        } else {
5158                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5159                        }
5160                    }
5161
5162                    1 => {
5163                        if let Some(value) = &self.creation_time {
5164                            ::fidl_next::wire::Envelope::encode_value::<
5165                                ::fidl_next::wire::Uint64,
5166                                ___E,
5167                            >(
5168                                value, preallocated.encoder, &mut out, ()
5169                            )?;
5170                        } else {
5171                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5172                        }
5173                    }
5174
5175                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5176                }
5177                unsafe {
5178                    preallocated.write_next(out.assume_init_ref());
5179                }
5180            }
5181
5182            ::fidl_next::wire::Table::encode_len(table, max_ord);
5183
5184            Ok(())
5185        }
5186    }
5187
5188    impl<'de> ::fidl_next::FromWire<crate::wire::MutableNodeAttributes<'de>> for MutableNodeAttributes {
5189        #[inline]
5190        fn from_wire(wire_: crate::wire::MutableNodeAttributes<'de>) -> Self {
5191            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5192
5193            let creation_time = wire_.table.get(1);
5194
5195            let modification_time = wire_.table.get(2);
5196
5197            let mode = wire_.table.get(3);
5198
5199            let uid = wire_.table.get(4);
5200
5201            let gid = wire_.table.get(5);
5202
5203            let rdev = wire_.table.get(6);
5204
5205            let access_time = wire_.table.get(7);
5206
5207            let casefold = wire_.table.get(8);
5208
5209            let selinux_context = wire_.table.get(9);
5210
5211            let wrapping_key_id = wire_.table.get(10);
5212
5213            Self {
5214                creation_time: creation_time.map(|envelope| {
5215                    ::fidl_next::FromWire::from_wire(unsafe {
5216                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5217                    })
5218                }),
5219
5220                modification_time: modification_time.map(|envelope| {
5221                    ::fidl_next::FromWire::from_wire(unsafe {
5222                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5223                    })
5224                }),
5225
5226                mode: mode.map(|envelope| {
5227                    ::fidl_next::FromWire::from_wire(unsafe {
5228                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5229                    })
5230                }),
5231
5232                uid: uid.map(|envelope| {
5233                    ::fidl_next::FromWire::from_wire(unsafe {
5234                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5235                    })
5236                }),
5237
5238                gid: gid.map(|envelope| {
5239                    ::fidl_next::FromWire::from_wire(unsafe {
5240                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5241                    })
5242                }),
5243
5244                rdev: rdev.map(|envelope| {
5245                    ::fidl_next::FromWire::from_wire(unsafe {
5246                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5247                    })
5248                }),
5249
5250                access_time: access_time.map(|envelope| {
5251                    ::fidl_next::FromWire::from_wire(unsafe {
5252                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5253                    })
5254                }),
5255
5256                casefold: casefold.map(|envelope| {
5257                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
5258                }),
5259
5260                selinux_context: selinux_context.map(|envelope| {
5261                    ::fidl_next::FromWire::from_wire(unsafe {
5262                        envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
5263                    })
5264                }),
5265
5266                wrapping_key_id: wrapping_key_id.map(|envelope| {
5267                    ::fidl_next::FromWire::from_wire(unsafe {
5268                        envelope.read_unchecked::<[u8; 16]>()
5269                    })
5270                }),
5271            }
5272        }
5273    }
5274
5275    impl<'de> ::fidl_next::FromWireRef<crate::wire::MutableNodeAttributes<'de>>
5276        for MutableNodeAttributes
5277    {
5278        #[inline]
5279        fn from_wire_ref(wire: &crate::wire::MutableNodeAttributes<'de>) -> Self {
5280            Self {
5281                creation_time: wire.table.get(1).map(|envelope| {
5282                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5283                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5284                    })
5285                }),
5286
5287                modification_time: wire.table.get(2).map(|envelope| {
5288                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5289                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5290                    })
5291                }),
5292
5293                mode: wire.table.get(3).map(|envelope| {
5294                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5295                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5296                    })
5297                }),
5298
5299                uid: wire.table.get(4).map(|envelope| {
5300                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5301                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5302                    })
5303                }),
5304
5305                gid: wire.table.get(5).map(|envelope| {
5306                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5307                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5308                    })
5309                }),
5310
5311                rdev: wire.table.get(6).map(|envelope| {
5312                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5313                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5314                    })
5315                }),
5316
5317                access_time: wire.table.get(7).map(|envelope| {
5318                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5319                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5320                    })
5321                }),
5322
5323                casefold: wire.table.get(8).map(|envelope| {
5324                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5325                        envelope.deref_unchecked::<bool>()
5326                    })
5327                }),
5328
5329                selinux_context: wire.table.get(9).map(|envelope| {
5330                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5331                        envelope.deref_unchecked::<crate::wire::SelinuxContext<'de>>()
5332                    })
5333                }),
5334
5335                wrapping_key_id: wire.table.get(10).map(|envelope| {
5336                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5337                        envelope.deref_unchecked::<[u8; 16]>()
5338                    })
5339                }),
5340            }
5341        }
5342    }
5343
5344    ::fidl_next::bitflags::bitflags! {
5345        #[doc = " A node may have multiple supported representations when opening, even though\n it may have a fixed underlying identity.\n\n Today, a file is accessed via the [`File`] protocol, and sends a\n [`Representation.FileInfo`] when opened with `GET_REPRESENTATION`. However,\n in the future we might introduce a more sophisticated `FileV2` protocol, or\n a more efficient `SuperFastFile` backed by a specialized kernel object. New\n clients can request the more advanced representations by specifying the\n corresponding bits in [`NodeProtocolKinds`], whereas existing clients would\n continue to talk to the node via the old representation.\n\n [`NodeProtocolKinds`] enables forward-compatibility through a form of protocol\n negotiation.\n\n The elements have one-to-one correspondence with the members of\n [`Representation`].\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeProtocolKinds: u64 {
5346            #[doc = " The connector representation of a node.\n\n The connection will speak either [`Node`] or the target protocol,\n depending on the flags used during opening.\n"]const CONNECTOR = 1;
5347            #[doc = " The directory representation of a node.\n\n The connection will speak the [`Directory`] protocol.\n"]const DIRECTORY = 2;
5348            #[doc = " The file representation of a node.\n\n The connection will speak the [`File`] protocol.\n"]const FILE = 4;
5349            #[doc = " The symlink representation of a node.\n\n The connection will speak the [`Symlink`] protocol.\n"]const SYMLINK = 8;
5350            const _ = !0;
5351        }
5352    }
5353
5354    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E> for NodeProtocolKinds
5355    where
5356        ___E: ?Sized,
5357    {
5358        #[inline]
5359        fn encode(
5360            self,
5361            encoder: &mut ___E,
5362            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
5363            _: (),
5364        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5365            ::fidl_next::Encode::encode(&self, encoder, out, ())
5366        }
5367    }
5368
5369    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E>
5370        for &'a NodeProtocolKinds
5371    where
5372        ___E: ?Sized,
5373    {
5374        #[inline]
5375        fn encode(
5376            self,
5377            _: &mut ___E,
5378            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
5379            _: (),
5380        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5381            ::fidl_next::munge!(let crate::wire::NodeProtocolKinds { value } = out);
5382
5383            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
5384            Ok(())
5385        }
5386    }
5387
5388    impl ::core::convert::From<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5389        fn from(wire: crate::wire::NodeProtocolKinds) -> Self {
5390            Self::from_bits_retain(u64::from(wire.value))
5391        }
5392    }
5393
5394    impl ::fidl_next::FromWire<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5395        #[inline]
5396        fn from_wire(wire: crate::wire::NodeProtocolKinds) -> Self {
5397            Self::from(wire)
5398        }
5399    }
5400
5401    impl ::fidl_next::FromWireRef<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5402        #[inline]
5403        fn from_wire_ref(wire: &crate::wire::NodeProtocolKinds) -> Self {
5404            Self::from(*wire)
5405        }
5406    }
5407
5408    #[doc = " Denotes which hash algorithm is used to build the merkle tree for\n fsverity-enabled files.\n"]
5409    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5410    #[repr(u8)]
5411    pub enum HashAlgorithm {
5412        Sha256 = 1,
5413        Sha512 = 2,
5414        UnknownOrdinal_(u8) = 3,
5415    }
5416    impl ::std::convert::From<u8> for HashAlgorithm {
5417        fn from(value: u8) -> Self {
5418            match value {
5419                1 => Self::Sha256,
5420                2 => Self::Sha512,
5421
5422                _ => Self::UnknownOrdinal_(value),
5423            }
5424        }
5425    }
5426
5427    unsafe impl<___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for HashAlgorithm
5428    where
5429        ___E: ?Sized,
5430    {
5431        #[inline]
5432        fn encode(
5433            self,
5434            encoder: &mut ___E,
5435            out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
5436            _: (),
5437        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5438            ::fidl_next::Encode::encode(&self, encoder, out, ())
5439        }
5440    }
5441
5442    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for &'a HashAlgorithm
5443    where
5444        ___E: ?Sized,
5445    {
5446        #[inline]
5447        fn encode(
5448            self,
5449            encoder: &mut ___E,
5450            out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
5451            _: (),
5452        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5453            ::fidl_next::munge!(let crate::wire::HashAlgorithm { value } = out);
5454            let _ = value.write(u8::from(match *self {
5455                HashAlgorithm::Sha256 => 1,
5456
5457                HashAlgorithm::Sha512 => 2,
5458
5459                HashAlgorithm::UnknownOrdinal_(value) => value,
5460            }));
5461
5462            Ok(())
5463        }
5464    }
5465
5466    impl ::core::convert::From<crate::wire::HashAlgorithm> for HashAlgorithm {
5467        fn from(wire: crate::wire::HashAlgorithm) -> Self {
5468            match u8::from(wire.value) {
5469                1 => Self::Sha256,
5470
5471                2 => Self::Sha512,
5472
5473                value => Self::UnknownOrdinal_(value),
5474            }
5475        }
5476    }
5477
5478    impl ::fidl_next::FromWire<crate::wire::HashAlgorithm> for HashAlgorithm {
5479        #[inline]
5480        fn from_wire(wire: crate::wire::HashAlgorithm) -> Self {
5481            Self::from(wire)
5482        }
5483    }
5484
5485    impl ::fidl_next::FromWireRef<crate::wire::HashAlgorithm> for HashAlgorithm {
5486        #[inline]
5487        fn from_wire_ref(wire: &crate::wire::HashAlgorithm) -> Self {
5488            Self::from(*wire)
5489        }
5490    }
5491
5492    #[doc = " Set of options used to enable verity on a file.\n"]
5493    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5494    pub struct VerificationOptions {
5495        pub hash_algorithm: ::core::option::Option<crate::natural::HashAlgorithm>,
5496
5497        pub salt: ::core::option::Option<::std::vec::Vec<u8>>,
5498    }
5499
5500    impl VerificationOptions {
5501        fn __max_ordinal(&self) -> usize {
5502            if self.salt.is_some() {
5503                return 2;
5504            }
5505
5506            if self.hash_algorithm.is_some() {
5507                return 1;
5508            }
5509
5510            0
5511        }
5512    }
5513
5514    unsafe impl<___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
5515        for VerificationOptions
5516    where
5517        ___E: ::fidl_next::Encoder + ?Sized,
5518    {
5519        #[inline]
5520        fn encode(
5521            mut self,
5522            encoder: &mut ___E,
5523            out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
5524            _: (),
5525        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5526            ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
5527
5528            let max_ord = self.__max_ordinal();
5529
5530            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5531            ::fidl_next::Wire::zero_padding(&mut out);
5532
5533            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5534                ::fidl_next::wire::Envelope,
5535            >(encoder, max_ord);
5536
5537            for i in 1..=max_ord {
5538                match i {
5539                    2 => {
5540                        if let Some(value) = self.salt.take() {
5541                            ::fidl_next::wire::Envelope::encode_value::<
5542                                ::fidl_next::wire::Vector<'static, u8>,
5543                                ___E,
5544                            >(
5545                                value, preallocated.encoder, &mut out, (32, ())
5546                            )?;
5547                        } else {
5548                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5549                        }
5550                    }
5551
5552                    1 => {
5553                        if let Some(value) = self.hash_algorithm.take() {
5554                            ::fidl_next::wire::Envelope::encode_value::<
5555                                crate::wire::HashAlgorithm,
5556                                ___E,
5557                            >(
5558                                value, preallocated.encoder, &mut out, ()
5559                            )?;
5560                        } else {
5561                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5562                        }
5563                    }
5564
5565                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5566                }
5567                unsafe {
5568                    preallocated.write_next(out.assume_init_ref());
5569                }
5570            }
5571
5572            ::fidl_next::wire::Table::encode_len(table, max_ord);
5573
5574            Ok(())
5575        }
5576    }
5577
5578    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
5579        for &'a VerificationOptions
5580    where
5581        ___E: ::fidl_next::Encoder + ?Sized,
5582    {
5583        #[inline]
5584        fn encode(
5585            self,
5586            encoder: &mut ___E,
5587            out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
5588            _: (),
5589        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5590            ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
5591
5592            let max_ord = self.__max_ordinal();
5593
5594            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5595            ::fidl_next::Wire::zero_padding(&mut out);
5596
5597            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5598                ::fidl_next::wire::Envelope,
5599            >(encoder, max_ord);
5600
5601            for i in 1..=max_ord {
5602                match i {
5603                    2 => {
5604                        if let Some(value) = &self.salt {
5605                            ::fidl_next::wire::Envelope::encode_value::<
5606                                ::fidl_next::wire::Vector<'static, u8>,
5607                                ___E,
5608                            >(
5609                                value, preallocated.encoder, &mut out, (32, ())
5610                            )?;
5611                        } else {
5612                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5613                        }
5614                    }
5615
5616                    1 => {
5617                        if let Some(value) = &self.hash_algorithm {
5618                            ::fidl_next::wire::Envelope::encode_value::<
5619                                crate::wire::HashAlgorithm,
5620                                ___E,
5621                            >(
5622                                value, preallocated.encoder, &mut out, ()
5623                            )?;
5624                        } else {
5625                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5626                        }
5627                    }
5628
5629                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5630                }
5631                unsafe {
5632                    preallocated.write_next(out.assume_init_ref());
5633                }
5634            }
5635
5636            ::fidl_next::wire::Table::encode_len(table, max_ord);
5637
5638            Ok(())
5639        }
5640    }
5641
5642    impl<'de> ::fidl_next::FromWire<crate::wire::VerificationOptions<'de>> for VerificationOptions {
5643        #[inline]
5644        fn from_wire(wire_: crate::wire::VerificationOptions<'de>) -> Self {
5645            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5646
5647            let hash_algorithm = wire_.table.get(1);
5648
5649            let salt = wire_.table.get(2);
5650
5651            Self {
5652                hash_algorithm: hash_algorithm.map(|envelope| {
5653                    ::fidl_next::FromWire::from_wire(unsafe {
5654                        envelope.read_unchecked::<crate::wire::HashAlgorithm>()
5655                    })
5656                }),
5657
5658                salt: salt.map(|envelope| {
5659                    ::fidl_next::FromWire::from_wire(unsafe {
5660                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5661                    })
5662                }),
5663            }
5664        }
5665    }
5666
5667    impl<'de> ::fidl_next::FromWireRef<crate::wire::VerificationOptions<'de>> for VerificationOptions {
5668        #[inline]
5669        fn from_wire_ref(wire: &crate::wire::VerificationOptions<'de>) -> Self {
5670            Self {
5671                hash_algorithm: wire.table.get(1).map(|envelope| {
5672                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5673                        envelope.deref_unchecked::<crate::wire::HashAlgorithm>()
5674                    })
5675                }),
5676
5677                salt: wire.table.get(2).map(|envelope| {
5678                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5679                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5680                    })
5681                }),
5682            }
5683        }
5684    }
5685
5686    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5687    pub struct ImmutableNodeAttributes {
5688        pub protocols: ::core::option::Option<crate::natural::NodeProtocolKinds>,
5689
5690        pub abilities: ::core::option::Option<crate::natural::Operations>,
5691
5692        pub content_size: ::core::option::Option<u64>,
5693
5694        pub storage_size: ::core::option::Option<u64>,
5695
5696        pub link_count: ::core::option::Option<u64>,
5697
5698        pub id: ::core::option::Option<u64>,
5699
5700        pub change_time: ::core::option::Option<u64>,
5701
5702        pub options: ::core::option::Option<crate::natural::VerificationOptions>,
5703
5704        pub root_hash: ::core::option::Option<::std::vec::Vec<u8>>,
5705
5706        pub verity_enabled: ::core::option::Option<bool>,
5707    }
5708
5709    impl ImmutableNodeAttributes {
5710        fn __max_ordinal(&self) -> usize {
5711            if self.verity_enabled.is_some() {
5712                return 10;
5713            }
5714
5715            if self.root_hash.is_some() {
5716                return 9;
5717            }
5718
5719            if self.options.is_some() {
5720                return 8;
5721            }
5722
5723            if self.change_time.is_some() {
5724                return 7;
5725            }
5726
5727            if self.id.is_some() {
5728                return 6;
5729            }
5730
5731            if self.link_count.is_some() {
5732                return 5;
5733            }
5734
5735            if self.storage_size.is_some() {
5736                return 4;
5737            }
5738
5739            if self.content_size.is_some() {
5740                return 3;
5741            }
5742
5743            if self.abilities.is_some() {
5744                return 2;
5745            }
5746
5747            if self.protocols.is_some() {
5748                return 1;
5749            }
5750
5751            0
5752        }
5753    }
5754
5755    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
5756        for ImmutableNodeAttributes
5757    where
5758        ___E: ::fidl_next::Encoder + ?Sized,
5759    {
5760        #[inline]
5761        fn encode(
5762            mut self,
5763            encoder: &mut ___E,
5764            out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
5765            _: (),
5766        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5767            ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
5768
5769            let max_ord = self.__max_ordinal();
5770
5771            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5772            ::fidl_next::Wire::zero_padding(&mut out);
5773
5774            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5775                ::fidl_next::wire::Envelope,
5776            >(encoder, max_ord);
5777
5778            for i in 1..=max_ord {
5779                match i {
5780                    10 => {
5781                        if let Some(value) = self.verity_enabled.take() {
5782                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5783                                value,
5784                                preallocated.encoder,
5785                                &mut out,
5786                                (),
5787                            )?;
5788                        } else {
5789                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5790                        }
5791                    }
5792
5793                    9 => {
5794                        if let Some(value) = self.root_hash.take() {
5795                            ::fidl_next::wire::Envelope::encode_value::<
5796                                ::fidl_next::wire::Vector<'static, u8>,
5797                                ___E,
5798                            >(
5799                                value, preallocated.encoder, &mut out, (64, ())
5800                            )?;
5801                        } else {
5802                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5803                        }
5804                    }
5805
5806                    8 => {
5807                        if let Some(value) = self.options.take() {
5808                            ::fidl_next::wire::Envelope::encode_value::<
5809                                crate::wire::VerificationOptions<'static>,
5810                                ___E,
5811                            >(
5812                                value, preallocated.encoder, &mut out, ()
5813                            )?;
5814                        } else {
5815                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5816                        }
5817                    }
5818
5819                    7 => {
5820                        if let Some(value) = self.change_time.take() {
5821                            ::fidl_next::wire::Envelope::encode_value::<
5822                                ::fidl_next::wire::Uint64,
5823                                ___E,
5824                            >(
5825                                value, preallocated.encoder, &mut out, ()
5826                            )?;
5827                        } else {
5828                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5829                        }
5830                    }
5831
5832                    6 => {
5833                        if let Some(value) = self.id.take() {
5834                            ::fidl_next::wire::Envelope::encode_value::<
5835                                ::fidl_next::wire::Uint64,
5836                                ___E,
5837                            >(
5838                                value, preallocated.encoder, &mut out, ()
5839                            )?;
5840                        } else {
5841                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5842                        }
5843                    }
5844
5845                    5 => {
5846                        if let Some(value) = self.link_count.take() {
5847                            ::fidl_next::wire::Envelope::encode_value::<
5848                                ::fidl_next::wire::Uint64,
5849                                ___E,
5850                            >(
5851                                value, preallocated.encoder, &mut out, ()
5852                            )?;
5853                        } else {
5854                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5855                        }
5856                    }
5857
5858                    4 => {
5859                        if let Some(value) = self.storage_size.take() {
5860                            ::fidl_next::wire::Envelope::encode_value::<
5861                                ::fidl_next::wire::Uint64,
5862                                ___E,
5863                            >(
5864                                value, preallocated.encoder, &mut out, ()
5865                            )?;
5866                        } else {
5867                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5868                        }
5869                    }
5870
5871                    3 => {
5872                        if let Some(value) = self.content_size.take() {
5873                            ::fidl_next::wire::Envelope::encode_value::<
5874                                ::fidl_next::wire::Uint64,
5875                                ___E,
5876                            >(
5877                                value, preallocated.encoder, &mut out, ()
5878                            )?;
5879                        } else {
5880                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5881                        }
5882                    }
5883
5884                    2 => {
5885                        if let Some(value) = self.abilities.take() {
5886                            ::fidl_next::wire::Envelope::encode_value::<
5887                                crate::wire::Operations,
5888                                ___E,
5889                            >(
5890                                value, preallocated.encoder, &mut out, ()
5891                            )?;
5892                        } else {
5893                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5894                        }
5895                    }
5896
5897                    1 => {
5898                        if let Some(value) = self.protocols.take() {
5899                            ::fidl_next::wire::Envelope::encode_value::<
5900                                crate::wire::NodeProtocolKinds,
5901                                ___E,
5902                            >(
5903                                value, preallocated.encoder, &mut out, ()
5904                            )?;
5905                        } else {
5906                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5907                        }
5908                    }
5909
5910                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5911                }
5912                unsafe {
5913                    preallocated.write_next(out.assume_init_ref());
5914                }
5915            }
5916
5917            ::fidl_next::wire::Table::encode_len(table, max_ord);
5918
5919            Ok(())
5920        }
5921    }
5922
5923    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
5924        for &'a ImmutableNodeAttributes
5925    where
5926        ___E: ::fidl_next::Encoder + ?Sized,
5927    {
5928        #[inline]
5929        fn encode(
5930            self,
5931            encoder: &mut ___E,
5932            out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
5933            _: (),
5934        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5935            ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
5936
5937            let max_ord = self.__max_ordinal();
5938
5939            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5940            ::fidl_next::Wire::zero_padding(&mut out);
5941
5942            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5943                ::fidl_next::wire::Envelope,
5944            >(encoder, max_ord);
5945
5946            for i in 1..=max_ord {
5947                match i {
5948                    10 => {
5949                        if let Some(value) = &self.verity_enabled {
5950                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5951                                value,
5952                                preallocated.encoder,
5953                                &mut out,
5954                                (),
5955                            )?;
5956                        } else {
5957                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5958                        }
5959                    }
5960
5961                    9 => {
5962                        if let Some(value) = &self.root_hash {
5963                            ::fidl_next::wire::Envelope::encode_value::<
5964                                ::fidl_next::wire::Vector<'static, u8>,
5965                                ___E,
5966                            >(
5967                                value, preallocated.encoder, &mut out, (64, ())
5968                            )?;
5969                        } else {
5970                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5971                        }
5972                    }
5973
5974                    8 => {
5975                        if let Some(value) = &self.options {
5976                            ::fidl_next::wire::Envelope::encode_value::<
5977                                crate::wire::VerificationOptions<'static>,
5978                                ___E,
5979                            >(
5980                                value, preallocated.encoder, &mut out, ()
5981                            )?;
5982                        } else {
5983                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5984                        }
5985                    }
5986
5987                    7 => {
5988                        if let Some(value) = &self.change_time {
5989                            ::fidl_next::wire::Envelope::encode_value::<
5990                                ::fidl_next::wire::Uint64,
5991                                ___E,
5992                            >(
5993                                value, preallocated.encoder, &mut out, ()
5994                            )?;
5995                        } else {
5996                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5997                        }
5998                    }
5999
6000                    6 => {
6001                        if let Some(value) = &self.id {
6002                            ::fidl_next::wire::Envelope::encode_value::<
6003                                ::fidl_next::wire::Uint64,
6004                                ___E,
6005                            >(
6006                                value, preallocated.encoder, &mut out, ()
6007                            )?;
6008                        } else {
6009                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6010                        }
6011                    }
6012
6013                    5 => {
6014                        if let Some(value) = &self.link_count {
6015                            ::fidl_next::wire::Envelope::encode_value::<
6016                                ::fidl_next::wire::Uint64,
6017                                ___E,
6018                            >(
6019                                value, preallocated.encoder, &mut out, ()
6020                            )?;
6021                        } else {
6022                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6023                        }
6024                    }
6025
6026                    4 => {
6027                        if let Some(value) = &self.storage_size {
6028                            ::fidl_next::wire::Envelope::encode_value::<
6029                                ::fidl_next::wire::Uint64,
6030                                ___E,
6031                            >(
6032                                value, preallocated.encoder, &mut out, ()
6033                            )?;
6034                        } else {
6035                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6036                        }
6037                    }
6038
6039                    3 => {
6040                        if let Some(value) = &self.content_size {
6041                            ::fidl_next::wire::Envelope::encode_value::<
6042                                ::fidl_next::wire::Uint64,
6043                                ___E,
6044                            >(
6045                                value, preallocated.encoder, &mut out, ()
6046                            )?;
6047                        } else {
6048                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6049                        }
6050                    }
6051
6052                    2 => {
6053                        if let Some(value) = &self.abilities {
6054                            ::fidl_next::wire::Envelope::encode_value::<
6055                                crate::wire::Operations,
6056                                ___E,
6057                            >(
6058                                value, preallocated.encoder, &mut out, ()
6059                            )?;
6060                        } else {
6061                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6062                        }
6063                    }
6064
6065                    1 => {
6066                        if let Some(value) = &self.protocols {
6067                            ::fidl_next::wire::Envelope::encode_value::<
6068                                crate::wire::NodeProtocolKinds,
6069                                ___E,
6070                            >(
6071                                value, preallocated.encoder, &mut out, ()
6072                            )?;
6073                        } else {
6074                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6075                        }
6076                    }
6077
6078                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6079                }
6080                unsafe {
6081                    preallocated.write_next(out.assume_init_ref());
6082                }
6083            }
6084
6085            ::fidl_next::wire::Table::encode_len(table, max_ord);
6086
6087            Ok(())
6088        }
6089    }
6090
6091    impl<'de> ::fidl_next::FromWire<crate::wire::ImmutableNodeAttributes<'de>>
6092        for ImmutableNodeAttributes
6093    {
6094        #[inline]
6095        fn from_wire(wire_: crate::wire::ImmutableNodeAttributes<'de>) -> Self {
6096            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6097
6098            let protocols = wire_.table.get(1);
6099
6100            let abilities = wire_.table.get(2);
6101
6102            let content_size = wire_.table.get(3);
6103
6104            let storage_size = wire_.table.get(4);
6105
6106            let link_count = wire_.table.get(5);
6107
6108            let id = wire_.table.get(6);
6109
6110            let change_time = wire_.table.get(7);
6111
6112            let options = wire_.table.get(8);
6113
6114            let root_hash = wire_.table.get(9);
6115
6116            let verity_enabled = wire_.table.get(10);
6117
6118            Self {
6119                protocols: protocols.map(|envelope| {
6120                    ::fidl_next::FromWire::from_wire(unsafe {
6121                        envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
6122                    })
6123                }),
6124
6125                abilities: abilities.map(|envelope| {
6126                    ::fidl_next::FromWire::from_wire(unsafe {
6127                        envelope.read_unchecked::<crate::wire::Operations>()
6128                    })
6129                }),
6130
6131                content_size: content_size.map(|envelope| {
6132                    ::fidl_next::FromWire::from_wire(unsafe {
6133                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6134                    })
6135                }),
6136
6137                storage_size: storage_size.map(|envelope| {
6138                    ::fidl_next::FromWire::from_wire(unsafe {
6139                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6140                    })
6141                }),
6142
6143                link_count: link_count.map(|envelope| {
6144                    ::fidl_next::FromWire::from_wire(unsafe {
6145                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6146                    })
6147                }),
6148
6149                id: id.map(|envelope| {
6150                    ::fidl_next::FromWire::from_wire(unsafe {
6151                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6152                    })
6153                }),
6154
6155                change_time: change_time.map(|envelope| {
6156                    ::fidl_next::FromWire::from_wire(unsafe {
6157                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6158                    })
6159                }),
6160
6161                options: options.map(|envelope| {
6162                    ::fidl_next::FromWire::from_wire(unsafe {
6163                        envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
6164                    })
6165                }),
6166
6167                root_hash: root_hash.map(|envelope| {
6168                    ::fidl_next::FromWire::from_wire(unsafe {
6169                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6170                    })
6171                }),
6172
6173                verity_enabled: verity_enabled.map(|envelope| {
6174                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
6175                }),
6176            }
6177        }
6178    }
6179
6180    impl<'de> ::fidl_next::FromWireRef<crate::wire::ImmutableNodeAttributes<'de>>
6181        for ImmutableNodeAttributes
6182    {
6183        #[inline]
6184        fn from_wire_ref(wire: &crate::wire::ImmutableNodeAttributes<'de>) -> Self {
6185            Self {
6186                protocols: wire.table.get(1).map(|envelope| {
6187                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6188                        envelope.deref_unchecked::<crate::wire::NodeProtocolKinds>()
6189                    })
6190                }),
6191
6192                abilities: wire.table.get(2).map(|envelope| {
6193                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6194                        envelope.deref_unchecked::<crate::wire::Operations>()
6195                    })
6196                }),
6197
6198                content_size: wire.table.get(3).map(|envelope| {
6199                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6200                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6201                    })
6202                }),
6203
6204                storage_size: wire.table.get(4).map(|envelope| {
6205                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6206                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6207                    })
6208                }),
6209
6210                link_count: wire.table.get(5).map(|envelope| {
6211                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6212                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6213                    })
6214                }),
6215
6216                id: wire.table.get(6).map(|envelope| {
6217                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6218                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6219                    })
6220                }),
6221
6222                change_time: wire.table.get(7).map(|envelope| {
6223                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6224                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6225                    })
6226                }),
6227
6228                options: wire.table.get(8).map(|envelope| {
6229                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6230                        envelope.deref_unchecked::<crate::wire::VerificationOptions<'de>>()
6231                    })
6232                }),
6233
6234                root_hash: wire.table.get(9).map(|envelope| {
6235                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6236                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6237                    })
6238                }),
6239
6240                verity_enabled: wire.table.get(10).map(|envelope| {
6241                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6242                        envelope.deref_unchecked::<bool>()
6243                    })
6244                }),
6245            }
6246        }
6247    }
6248
6249    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6250    pub struct NodeAttributes2 {
6251        pub mutable_attributes: crate::natural::MutableNodeAttributes,
6252
6253        pub immutable_attributes: crate::natural::ImmutableNodeAttributes,
6254    }
6255
6256    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
6257        for NodeAttributes2
6258    where
6259        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6260        ___E: ::fidl_next::Encoder,
6261    {
6262        #[inline]
6263        fn encode(
6264            self,
6265            encoder_: &mut ___E,
6266            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
6267            _: (),
6268        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6269            ::fidl_next::munge! {
6270                let crate::wire::NodeAttributes2 {
6271                    mutable_attributes,
6272                    immutable_attributes,
6273
6274                } = out_;
6275            }
6276
6277            ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
6278
6279            let mut _field =
6280                unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
6281
6282            ::fidl_next::Encode::encode(
6283                self.immutable_attributes,
6284                encoder_,
6285                immutable_attributes,
6286                (),
6287            )?;
6288
6289            let mut _field =
6290                unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
6291
6292            Ok(())
6293        }
6294    }
6295
6296    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
6297        for &'a NodeAttributes2
6298    where
6299        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6300        ___E: ::fidl_next::Encoder,
6301    {
6302        #[inline]
6303        fn encode(
6304            self,
6305            encoder_: &mut ___E,
6306            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
6307            _: (),
6308        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6309            ::fidl_next::munge! {
6310                let crate::wire::NodeAttributes2 {
6311                    mutable_attributes,
6312                    immutable_attributes,
6313
6314                } = out_;
6315            }
6316
6317            ::fidl_next::Encode::encode(
6318                &self.mutable_attributes,
6319                encoder_,
6320                mutable_attributes,
6321                (),
6322            )?;
6323
6324            let mut _field =
6325                unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
6326
6327            ::fidl_next::Encode::encode(
6328                &self.immutable_attributes,
6329                encoder_,
6330                immutable_attributes,
6331                (),
6332            )?;
6333
6334            let mut _field =
6335                unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
6336
6337            Ok(())
6338        }
6339    }
6340
6341    unsafe impl<___E>
6342        ::fidl_next::EncodeOption<
6343            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6344            ___E,
6345        > for NodeAttributes2
6346    where
6347        ___E: ::fidl_next::Encoder + ?Sized,
6348        NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
6349    {
6350        #[inline]
6351        fn encode_option(
6352            this: ::core::option::Option<Self>,
6353            encoder: &mut ___E,
6354            out: &mut ::core::mem::MaybeUninit<
6355                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6356            >,
6357            _: (),
6358        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6359            if let Some(inner) = this {
6360                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6361                ::fidl_next::wire::Box::encode_present(out);
6362            } else {
6363                ::fidl_next::wire::Box::encode_absent(out);
6364            }
6365
6366            Ok(())
6367        }
6368    }
6369
6370    unsafe impl<'a, ___E>
6371        ::fidl_next::EncodeOption<
6372            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6373            ___E,
6374        > for &'a NodeAttributes2
6375    where
6376        ___E: ::fidl_next::Encoder + ?Sized,
6377        &'a NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
6378    {
6379        #[inline]
6380        fn encode_option(
6381            this: ::core::option::Option<Self>,
6382            encoder: &mut ___E,
6383            out: &mut ::core::mem::MaybeUninit<
6384                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6385            >,
6386            _: (),
6387        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6388            if let Some(inner) = this {
6389                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6390                ::fidl_next::wire::Box::encode_present(out);
6391            } else {
6392                ::fidl_next::wire::Box::encode_absent(out);
6393            }
6394
6395            Ok(())
6396        }
6397    }
6398
6399    impl<'de> ::fidl_next::FromWire<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
6400        #[inline]
6401        fn from_wire(wire: crate::wire::NodeAttributes2<'de>) -> Self {
6402            Self {
6403                mutable_attributes: ::fidl_next::FromWire::from_wire(wire.mutable_attributes),
6404
6405                immutable_attributes: ::fidl_next::FromWire::from_wire(wire.immutable_attributes),
6406            }
6407        }
6408    }
6409
6410    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
6411        #[inline]
6412        fn from_wire_ref(wire: &crate::wire::NodeAttributes2<'de>) -> Self {
6413            Self {
6414                mutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
6415                    &wire.mutable_attributes,
6416                ),
6417
6418                immutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
6419                    &wire.immutable_attributes,
6420                ),
6421            }
6422        }
6423    }
6424
6425    #[doc = " Information that describes the target node.\n"]
6426    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6427    pub struct NodeInfo {
6428        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6429    }
6430
6431    impl NodeInfo {
6432        fn __max_ordinal(&self) -> usize {
6433            if self.attributes.is_some() {
6434                return 1;
6435            }
6436
6437            0
6438        }
6439    }
6440
6441    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for NodeInfo
6442    where
6443        ___E: ::fidl_next::Encoder + ?Sized,
6444    {
6445        #[inline]
6446        fn encode(
6447            mut self,
6448            encoder: &mut ___E,
6449            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
6450            _: (),
6451        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6452            ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
6453
6454            let max_ord = self.__max_ordinal();
6455
6456            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6457            ::fidl_next::Wire::zero_padding(&mut out);
6458
6459            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6460                ::fidl_next::wire::Envelope,
6461            >(encoder, max_ord);
6462
6463            for i in 1..=max_ord {
6464                match i {
6465                    1 => {
6466                        if let Some(value) = self.attributes.take() {
6467                            ::fidl_next::wire::Envelope::encode_value::<
6468                                crate::wire::NodeAttributes2<'static>,
6469                                ___E,
6470                            >(
6471                                value, preallocated.encoder, &mut out, ()
6472                            )?;
6473                        } else {
6474                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6475                        }
6476                    }
6477
6478                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6479                }
6480                unsafe {
6481                    preallocated.write_next(out.assume_init_ref());
6482                }
6483            }
6484
6485            ::fidl_next::wire::Table::encode_len(table, max_ord);
6486
6487            Ok(())
6488        }
6489    }
6490
6491    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for &'a NodeInfo
6492    where
6493        ___E: ::fidl_next::Encoder + ?Sized,
6494    {
6495        #[inline]
6496        fn encode(
6497            self,
6498            encoder: &mut ___E,
6499            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
6500            _: (),
6501        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6502            ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
6503
6504            let max_ord = self.__max_ordinal();
6505
6506            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6507            ::fidl_next::Wire::zero_padding(&mut out);
6508
6509            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6510                ::fidl_next::wire::Envelope,
6511            >(encoder, max_ord);
6512
6513            for i in 1..=max_ord {
6514                match i {
6515                    1 => {
6516                        if let Some(value) = &self.attributes {
6517                            ::fidl_next::wire::Envelope::encode_value::<
6518                                crate::wire::NodeAttributes2<'static>,
6519                                ___E,
6520                            >(
6521                                value, preallocated.encoder, &mut out, ()
6522                            )?;
6523                        } else {
6524                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6525                        }
6526                    }
6527
6528                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6529                }
6530                unsafe {
6531                    preallocated.write_next(out.assume_init_ref());
6532                }
6533            }
6534
6535            ::fidl_next::wire::Table::encode_len(table, max_ord);
6536
6537            Ok(())
6538        }
6539    }
6540
6541    impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfo<'de>> for NodeInfo {
6542        #[inline]
6543        fn from_wire(wire_: crate::wire::NodeInfo<'de>) -> Self {
6544            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6545
6546            let attributes = wire_.table.get(1);
6547
6548            Self {
6549                attributes: attributes.map(|envelope| {
6550                    ::fidl_next::FromWire::from_wire(unsafe {
6551                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6552                    })
6553                }),
6554            }
6555        }
6556    }
6557
6558    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeInfo<'de>> for NodeInfo {
6559        #[inline]
6560        fn from_wire_ref(wire: &crate::wire::NodeInfo<'de>) -> Self {
6561            Self {
6562                attributes: wire.table.get(1).map(|envelope| {
6563                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6564                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6565                    })
6566                }),
6567            }
6568        }
6569    }
6570
6571    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6572    pub struct DirectoryInfo {
6573        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6574    }
6575
6576    impl DirectoryInfo {
6577        fn __max_ordinal(&self) -> usize {
6578            if self.attributes.is_some() {
6579                return 1;
6580            }
6581
6582            0
6583        }
6584    }
6585
6586    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E> for DirectoryInfo
6587    where
6588        ___E: ::fidl_next::Encoder + ?Sized,
6589    {
6590        #[inline]
6591        fn encode(
6592            mut self,
6593            encoder: &mut ___E,
6594            out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
6595            _: (),
6596        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6597            ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
6598
6599            let max_ord = self.__max_ordinal();
6600
6601            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6602            ::fidl_next::Wire::zero_padding(&mut out);
6603
6604            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6605                ::fidl_next::wire::Envelope,
6606            >(encoder, max_ord);
6607
6608            for i in 1..=max_ord {
6609                match i {
6610                    1 => {
6611                        if let Some(value) = self.attributes.take() {
6612                            ::fidl_next::wire::Envelope::encode_value::<
6613                                crate::wire::NodeAttributes2<'static>,
6614                                ___E,
6615                            >(
6616                                value, preallocated.encoder, &mut out, ()
6617                            )?;
6618                        } else {
6619                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6620                        }
6621                    }
6622
6623                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6624                }
6625                unsafe {
6626                    preallocated.write_next(out.assume_init_ref());
6627                }
6628            }
6629
6630            ::fidl_next::wire::Table::encode_len(table, max_ord);
6631
6632            Ok(())
6633        }
6634    }
6635
6636    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E>
6637        for &'a DirectoryInfo
6638    where
6639        ___E: ::fidl_next::Encoder + ?Sized,
6640    {
6641        #[inline]
6642        fn encode(
6643            self,
6644            encoder: &mut ___E,
6645            out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
6646            _: (),
6647        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6648            ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
6649
6650            let max_ord = self.__max_ordinal();
6651
6652            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6653            ::fidl_next::Wire::zero_padding(&mut out);
6654
6655            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6656                ::fidl_next::wire::Envelope,
6657            >(encoder, max_ord);
6658
6659            for i in 1..=max_ord {
6660                match i {
6661                    1 => {
6662                        if let Some(value) = &self.attributes {
6663                            ::fidl_next::wire::Envelope::encode_value::<
6664                                crate::wire::NodeAttributes2<'static>,
6665                                ___E,
6666                            >(
6667                                value, preallocated.encoder, &mut out, ()
6668                            )?;
6669                        } else {
6670                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6671                        }
6672                    }
6673
6674                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6675                }
6676                unsafe {
6677                    preallocated.write_next(out.assume_init_ref());
6678                }
6679            }
6680
6681            ::fidl_next::wire::Table::encode_len(table, max_ord);
6682
6683            Ok(())
6684        }
6685    }
6686
6687    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
6688        #[inline]
6689        fn from_wire(wire_: crate::wire::DirectoryInfo<'de>) -> Self {
6690            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6691
6692            let attributes = wire_.table.get(1);
6693
6694            Self {
6695                attributes: attributes.map(|envelope| {
6696                    ::fidl_next::FromWire::from_wire(unsafe {
6697                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6698                    })
6699                }),
6700            }
6701        }
6702    }
6703
6704    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
6705        #[inline]
6706        fn from_wire_ref(wire: &crate::wire::DirectoryInfo<'de>) -> Self {
6707            Self {
6708                attributes: wire.table.get(1).map(|envelope| {
6709                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6710                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6711                    })
6712                }),
6713            }
6714        }
6715    }
6716
6717    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6718    pub struct SymlinkInfo {
6719        pub target: ::core::option::Option<::std::vec::Vec<u8>>,
6720
6721        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6722    }
6723
6724    impl SymlinkInfo {
6725        fn __max_ordinal(&self) -> usize {
6726            if self.attributes.is_some() {
6727                return 2;
6728            }
6729
6730            if self.target.is_some() {
6731                return 1;
6732            }
6733
6734            0
6735        }
6736    }
6737
6738    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E> for SymlinkInfo
6739    where
6740        ___E: ::fidl_next::Encoder + ?Sized,
6741    {
6742        #[inline]
6743        fn encode(
6744            mut self,
6745            encoder: &mut ___E,
6746            out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
6747            _: (),
6748        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6749            ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
6750
6751            let max_ord = self.__max_ordinal();
6752
6753            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6754            ::fidl_next::Wire::zero_padding(&mut out);
6755
6756            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6757                ::fidl_next::wire::Envelope,
6758            >(encoder, max_ord);
6759
6760            for i in 1..=max_ord {
6761                match i {
6762                    2 => {
6763                        if let Some(value) = self.attributes.take() {
6764                            ::fidl_next::wire::Envelope::encode_value::<
6765                                crate::wire::NodeAttributes2<'static>,
6766                                ___E,
6767                            >(
6768                                value, preallocated.encoder, &mut out, ()
6769                            )?;
6770                        } else {
6771                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6772                        }
6773                    }
6774
6775                    1 => {
6776                        if let Some(value) = self.target.take() {
6777                            ::fidl_next::wire::Envelope::encode_value::<
6778                                ::fidl_next::wire::Vector<'static, u8>,
6779                                ___E,
6780                            >(
6781                                value, preallocated.encoder, &mut out, (4095, ())
6782                            )?;
6783                        } else {
6784                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6785                        }
6786                    }
6787
6788                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6789                }
6790                unsafe {
6791                    preallocated.write_next(out.assume_init_ref());
6792                }
6793            }
6794
6795            ::fidl_next::wire::Table::encode_len(table, max_ord);
6796
6797            Ok(())
6798        }
6799    }
6800
6801    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E>
6802        for &'a SymlinkInfo
6803    where
6804        ___E: ::fidl_next::Encoder + ?Sized,
6805    {
6806        #[inline]
6807        fn encode(
6808            self,
6809            encoder: &mut ___E,
6810            out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
6811            _: (),
6812        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6813            ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
6814
6815            let max_ord = self.__max_ordinal();
6816
6817            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6818            ::fidl_next::Wire::zero_padding(&mut out);
6819
6820            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6821                ::fidl_next::wire::Envelope,
6822            >(encoder, max_ord);
6823
6824            for i in 1..=max_ord {
6825                match i {
6826                    2 => {
6827                        if let Some(value) = &self.attributes {
6828                            ::fidl_next::wire::Envelope::encode_value::<
6829                                crate::wire::NodeAttributes2<'static>,
6830                                ___E,
6831                            >(
6832                                value, preallocated.encoder, &mut out, ()
6833                            )?;
6834                        } else {
6835                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6836                        }
6837                    }
6838
6839                    1 => {
6840                        if let Some(value) = &self.target {
6841                            ::fidl_next::wire::Envelope::encode_value::<
6842                                ::fidl_next::wire::Vector<'static, u8>,
6843                                ___E,
6844                            >(
6845                                value, preallocated.encoder, &mut out, (4095, ())
6846                            )?;
6847                        } else {
6848                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6849                        }
6850                    }
6851
6852                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6853                }
6854                unsafe {
6855                    preallocated.write_next(out.assume_init_ref());
6856                }
6857            }
6858
6859            ::fidl_next::wire::Table::encode_len(table, max_ord);
6860
6861            Ok(())
6862        }
6863    }
6864
6865    impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
6866        #[inline]
6867        fn from_wire(wire_: crate::wire::SymlinkInfo<'de>) -> Self {
6868            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6869
6870            let target = wire_.table.get(1);
6871
6872            let attributes = wire_.table.get(2);
6873
6874            Self {
6875                target: target.map(|envelope| {
6876                    ::fidl_next::FromWire::from_wire(unsafe {
6877                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6878                    })
6879                }),
6880
6881                attributes: attributes.map(|envelope| {
6882                    ::fidl_next::FromWire::from_wire(unsafe {
6883                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6884                    })
6885                }),
6886            }
6887        }
6888    }
6889
6890    impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
6891        #[inline]
6892        fn from_wire_ref(wire: &crate::wire::SymlinkInfo<'de>) -> Self {
6893            Self {
6894                target: wire.table.get(1).map(|envelope| {
6895                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6896                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6897                    })
6898                }),
6899
6900                attributes: wire.table.get(2).map(|envelope| {
6901                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6902                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6903                    })
6904                }),
6905            }
6906        }
6907    }
6908
6909    ::fidl_next::bitflags::bitflags! {
6910        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeAttributesQuery: u64 {
6911            #[doc = " Requests [`NodeAttributes.protocols`].\n"]const PROTOCOLS = 1;
6912            #[doc = " Requests [`NodeAttributes.abilities`].\n"]const ABILITIES = 2;
6913            #[doc = " Requests [`NodeAttributes.content_size`].\n"]const CONTENT_SIZE = 4;
6914            #[doc = " Requests [`NodeAttributes.storage_size`].\n"]const STORAGE_SIZE = 8;
6915            #[doc = " Requests [`NodeAttributes.link_count`].\n"]const LINK_COUNT = 16;
6916            #[doc = " Requests [`NodeAttributes.id`].\n"]const ID = 32;
6917            #[doc = " Requests [`NodeAttributes.creation_time`].\n"]const CREATION_TIME = 64;
6918            #[doc = " Requests [`NodeAttributes.modification_time`].\n"]const MODIFICATION_TIME = 128;
6919            #[doc = " Posix attributes.\n"]const MODE = 256;
6920            const UID = 512;
6921            const GID = 1024;
6922            const RDEV = 2048;
6923            const ACCESS_TIME = 4096;
6924            const CHANGE_TIME = 8192;
6925            #[doc = " Verity attributes.\n"]const OPTIONS = 16384;
6926            const ROOT_HASH = 32768;
6927            const VERITY_ENABLED = 65536;
6928            #[doc = " Casefold (case-insensitive filename) support.\n When true, file lookups will be case-insensitive but case-preserving. i.e. \"Foo\" will\n be stored verbatim but can be opened as \"foo\", \"fOO\", etc. Casefolding is done in\n accordance to the Unicode 12 NFD normalization and casefolding standard.\n"]const CASEFOLD = 131072;
6929            #[doc = " Requests [`MutableNodeAttributes.selinux_context`]. See that field for more detail.\n"]const SELINUX_CONTEXT = 262144;
6930            #[doc = " fscrypt attribute.\n"]const WRAPPING_KEY_ID = 524288;
6931            #[doc = " When this is queried in [`fuchsia.io/Node.GetAttributes`], it indicates to the filesystem\n that this node has been accessed and is pending an access time update given that any one of\n the following conditions are met:\n   * current_access_time <= current_modification_time\n   * current_access_time <= current_change_time\n   * current_access_time < current_time - duration(1 day)\n\n If any of the above conditions are met, `access_time` is updated to the current time before\n any queried node attributes are returned.\n\n This is compatible with Linux relatime mount.\n\n The rationale behind adding this `NodeAttributesQuery` is that some filesystems, e.g. Fxfs,\n are unable to identify when a file access has occured and thus update the access time. We\n allow for clients to communicate to the underlying filesystem that a file access has\n occurred and that it awaits for an update to access time.\n\n WARNING: If this is queried without a prior file access, as long as the above conditions\n are met, the node\'s access time will be updated. Not all filesystems will support this. The\n query will be ignored if the filesystem does not support this.\n"]const PENDING_ACCESS_TIME_UPDATE = 1048576;
6932            const _ = !0;
6933        }
6934    }
6935
6936    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
6937        for NodeAttributesQuery
6938    where
6939        ___E: ?Sized,
6940    {
6941        #[inline]
6942        fn encode(
6943            self,
6944            encoder: &mut ___E,
6945            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
6946            _: (),
6947        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6948            ::fidl_next::Encode::encode(&self, encoder, out, ())
6949        }
6950    }
6951
6952    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
6953        for &'a NodeAttributesQuery
6954    where
6955        ___E: ?Sized,
6956    {
6957        #[inline]
6958        fn encode(
6959            self,
6960            _: &mut ___E,
6961            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
6962            _: (),
6963        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6964            ::fidl_next::munge!(let crate::wire::NodeAttributesQuery { value } = out);
6965
6966            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
6967            Ok(())
6968        }
6969    }
6970
6971    impl ::core::convert::From<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6972        fn from(wire: crate::wire::NodeAttributesQuery) -> Self {
6973            Self::from_bits_retain(u64::from(wire.value))
6974        }
6975    }
6976
6977    impl ::fidl_next::FromWire<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6978        #[inline]
6979        fn from_wire(wire: crate::wire::NodeAttributesQuery) -> Self {
6980            Self::from(wire)
6981        }
6982    }
6983
6984    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6985        #[inline]
6986        fn from_wire_ref(wire: &crate::wire::NodeAttributesQuery) -> Self {
6987            Self::from(*wire)
6988        }
6989    }
6990
6991    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6992    #[repr(C)]
6993    pub struct NodeGetAttributesRequest {
6994        pub query: crate::natural::NodeAttributesQuery,
6995    }
6996
6997    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
6998        for NodeGetAttributesRequest
6999    where
7000        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7001    {
7002        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7003            Self,
7004            crate::wire::NodeGetAttributesRequest,
7005        > = unsafe {
7006            ::fidl_next::CopyOptimization::enable_if(
7007                true && <crate::natural::NodeAttributesQuery as ::fidl_next::Encode<
7008                    crate::wire::NodeAttributesQuery,
7009                    ___E,
7010                >>::COPY_OPTIMIZATION
7011                    .is_enabled(),
7012            )
7013        };
7014
7015        #[inline]
7016        fn encode(
7017            self,
7018            encoder_: &mut ___E,
7019            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
7020            _: (),
7021        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7022            ::fidl_next::munge! {
7023                let crate::wire::NodeGetAttributesRequest {
7024                    query,
7025
7026                } = out_;
7027            }
7028
7029            ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
7030
7031            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
7032
7033            Ok(())
7034        }
7035    }
7036
7037    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
7038        for &'a NodeGetAttributesRequest
7039    where
7040        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7041    {
7042        #[inline]
7043        fn encode(
7044            self,
7045            encoder_: &mut ___E,
7046            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
7047            _: (),
7048        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7049            ::fidl_next::munge! {
7050                let crate::wire::NodeGetAttributesRequest {
7051                    query,
7052
7053                } = out_;
7054            }
7055
7056            ::fidl_next::Encode::encode(&self.query, encoder_, query, ())?;
7057
7058            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
7059
7060            Ok(())
7061        }
7062    }
7063
7064    unsafe impl<___E>
7065        ::fidl_next::EncodeOption<
7066            ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7067            ___E,
7068        > for NodeGetAttributesRequest
7069    where
7070        ___E: ::fidl_next::Encoder + ?Sized,
7071        NodeGetAttributesRequest: ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
7072    {
7073        #[inline]
7074        fn encode_option(
7075            this: ::core::option::Option<Self>,
7076            encoder: &mut ___E,
7077            out: &mut ::core::mem::MaybeUninit<
7078                ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7079            >,
7080            _: (),
7081        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7082            if let Some(inner) = this {
7083                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7084                ::fidl_next::wire::Box::encode_present(out);
7085            } else {
7086                ::fidl_next::wire::Box::encode_absent(out);
7087            }
7088
7089            Ok(())
7090        }
7091    }
7092
7093    unsafe impl<'a, ___E>
7094        ::fidl_next::EncodeOption<
7095            ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7096            ___E,
7097        > for &'a NodeGetAttributesRequest
7098    where
7099        ___E: ::fidl_next::Encoder + ?Sized,
7100        &'a NodeGetAttributesRequest:
7101            ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
7102    {
7103        #[inline]
7104        fn encode_option(
7105            this: ::core::option::Option<Self>,
7106            encoder: &mut ___E,
7107            out: &mut ::core::mem::MaybeUninit<
7108                ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7109            >,
7110            _: (),
7111        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7112            if let Some(inner) = this {
7113                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7114                ::fidl_next::wire::Box::encode_present(out);
7115            } else {
7116                ::fidl_next::wire::Box::encode_absent(out);
7117            }
7118
7119            Ok(())
7120        }
7121    }
7122
7123    impl ::fidl_next::FromWire<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
7124        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7125            crate::wire::NodeGetAttributesRequest,
7126            Self,
7127        > = unsafe {
7128            ::fidl_next::CopyOptimization::enable_if(
7129                true && <crate::natural::NodeAttributesQuery as ::fidl_next::FromWire<
7130                    crate::wire::NodeAttributesQuery,
7131                >>::COPY_OPTIMIZATION
7132                    .is_enabled(),
7133            )
7134        };
7135
7136        #[inline]
7137        fn from_wire(wire: crate::wire::NodeGetAttributesRequest) -> Self {
7138            Self { query: ::fidl_next::FromWire::from_wire(wire.query) }
7139        }
7140    }
7141
7142    impl ::fidl_next::FromWireRef<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
7143        #[inline]
7144        fn from_wire_ref(wire: &crate::wire::NodeGetAttributesRequest) -> Self {
7145            Self { query: ::fidl_next::FromWireRef::from_wire_ref(&wire.query) }
7146        }
7147    }
7148
7149    #[doc = " Options which can be used when opening nodes. Unlike [`Flags`], these options are designed for\n specific use cases (e.g. to reduce round-trip latency when requesting attributes).\n"]
7150    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7151    pub struct Options {
7152        pub attributes: ::core::option::Option<crate::natural::NodeAttributesQuery>,
7153
7154        pub create_attributes: ::core::option::Option<crate::natural::MutableNodeAttributes>,
7155    }
7156
7157    impl Options {
7158        fn __max_ordinal(&self) -> usize {
7159            if self.create_attributes.is_some() {
7160                return 2;
7161            }
7162
7163            if self.attributes.is_some() {
7164                return 1;
7165            }
7166
7167            0
7168        }
7169    }
7170
7171    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for Options
7172    where
7173        ___E: ::fidl_next::Encoder + ?Sized,
7174    {
7175        #[inline]
7176        fn encode(
7177            mut self,
7178            encoder: &mut ___E,
7179            out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
7180            _: (),
7181        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7182            ::fidl_next::munge!(let crate::wire::Options { table } = out);
7183
7184            let max_ord = self.__max_ordinal();
7185
7186            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7187            ::fidl_next::Wire::zero_padding(&mut out);
7188
7189            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7190                ::fidl_next::wire::Envelope,
7191            >(encoder, max_ord);
7192
7193            for i in 1..=max_ord {
7194                match i {
7195                    2 => {
7196                        if let Some(value) = self.create_attributes.take() {
7197                            ::fidl_next::wire::Envelope::encode_value::<
7198                                crate::wire::MutableNodeAttributes<'static>,
7199                                ___E,
7200                            >(
7201                                value, preallocated.encoder, &mut out, ()
7202                            )?;
7203                        } else {
7204                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7205                        }
7206                    }
7207
7208                    1 => {
7209                        if let Some(value) = self.attributes.take() {
7210                            ::fidl_next::wire::Envelope::encode_value::<
7211                                crate::wire::NodeAttributesQuery,
7212                                ___E,
7213                            >(
7214                                value, preallocated.encoder, &mut out, ()
7215                            )?;
7216                        } else {
7217                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7218                        }
7219                    }
7220
7221                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7222                }
7223                unsafe {
7224                    preallocated.write_next(out.assume_init_ref());
7225                }
7226            }
7227
7228            ::fidl_next::wire::Table::encode_len(table, max_ord);
7229
7230            Ok(())
7231        }
7232    }
7233
7234    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for &'a Options
7235    where
7236        ___E: ::fidl_next::Encoder + ?Sized,
7237    {
7238        #[inline]
7239        fn encode(
7240            self,
7241            encoder: &mut ___E,
7242            out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
7243            _: (),
7244        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7245            ::fidl_next::munge!(let crate::wire::Options { table } = out);
7246
7247            let max_ord = self.__max_ordinal();
7248
7249            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7250            ::fidl_next::Wire::zero_padding(&mut out);
7251
7252            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7253                ::fidl_next::wire::Envelope,
7254            >(encoder, max_ord);
7255
7256            for i in 1..=max_ord {
7257                match i {
7258                    2 => {
7259                        if let Some(value) = &self.create_attributes {
7260                            ::fidl_next::wire::Envelope::encode_value::<
7261                                crate::wire::MutableNodeAttributes<'static>,
7262                                ___E,
7263                            >(
7264                                value, preallocated.encoder, &mut out, ()
7265                            )?;
7266                        } else {
7267                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7268                        }
7269                    }
7270
7271                    1 => {
7272                        if let Some(value) = &self.attributes {
7273                            ::fidl_next::wire::Envelope::encode_value::<
7274                                crate::wire::NodeAttributesQuery,
7275                                ___E,
7276                            >(
7277                                value, preallocated.encoder, &mut out, ()
7278                            )?;
7279                        } else {
7280                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7281                        }
7282                    }
7283
7284                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7285                }
7286                unsafe {
7287                    preallocated.write_next(out.assume_init_ref());
7288                }
7289            }
7290
7291            ::fidl_next::wire::Table::encode_len(table, max_ord);
7292
7293            Ok(())
7294        }
7295    }
7296
7297    impl<'de> ::fidl_next::FromWire<crate::wire::Options<'de>> for Options {
7298        #[inline]
7299        fn from_wire(wire_: crate::wire::Options<'de>) -> Self {
7300            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7301
7302            let attributes = wire_.table.get(1);
7303
7304            let create_attributes = wire_.table.get(2);
7305
7306            Self {
7307                attributes: attributes.map(|envelope| {
7308                    ::fidl_next::FromWire::from_wire(unsafe {
7309                        envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
7310                    })
7311                }),
7312
7313                create_attributes: create_attributes.map(|envelope| {
7314                    ::fidl_next::FromWire::from_wire(unsafe {
7315                        envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
7316                    })
7317                }),
7318            }
7319        }
7320    }
7321
7322    impl<'de> ::fidl_next::FromWireRef<crate::wire::Options<'de>> for Options {
7323        #[inline]
7324        fn from_wire_ref(wire: &crate::wire::Options<'de>) -> Self {
7325            Self {
7326                attributes: wire.table.get(1).map(|envelope| {
7327                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7328                        envelope.deref_unchecked::<crate::wire::NodeAttributesQuery>()
7329                    })
7330                }),
7331
7332                create_attributes: wire.table.get(2).map(|envelope| {
7333                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7334                        envelope.deref_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
7335                    })
7336                }),
7337            }
7338        }
7339    }
7340
7341    pub type DirectoryObject = ();
7342
7343    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7344    #[repr(u8)]
7345    pub enum DirentType {
7346        Unknown = 0,
7347        Directory = 4,
7348        BlockDevice = 6,
7349        File = 8,
7350        Symlink = 10,
7351        Service = 16,
7352        UnknownOrdinal_(u8) = 17,
7353    }
7354    impl ::std::convert::From<u8> for DirentType {
7355        fn from(value: u8) -> Self {
7356            match value {
7357                0 => Self::Unknown,
7358                4 => Self::Directory,
7359                6 => Self::BlockDevice,
7360                8 => Self::File,
7361                10 => Self::Symlink,
7362                16 => Self::Service,
7363
7364                _ => Self::UnknownOrdinal_(value),
7365            }
7366        }
7367    }
7368
7369    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for DirentType
7370    where
7371        ___E: ?Sized,
7372    {
7373        #[inline]
7374        fn encode(
7375            self,
7376            encoder: &mut ___E,
7377            out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
7378            _: (),
7379        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7380            ::fidl_next::Encode::encode(&self, encoder, out, ())
7381        }
7382    }
7383
7384    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for &'a DirentType
7385    where
7386        ___E: ?Sized,
7387    {
7388        #[inline]
7389        fn encode(
7390            self,
7391            encoder: &mut ___E,
7392            out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
7393            _: (),
7394        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7395            ::fidl_next::munge!(let crate::wire::DirentType { value } = out);
7396            let _ = value.write(u8::from(match *self {
7397                DirentType::Unknown => 0,
7398
7399                DirentType::Directory => 4,
7400
7401                DirentType::BlockDevice => 6,
7402
7403                DirentType::File => 8,
7404
7405                DirentType::Symlink => 10,
7406
7407                DirentType::Service => 16,
7408
7409                DirentType::UnknownOrdinal_(value) => value,
7410            }));
7411
7412            Ok(())
7413        }
7414    }
7415
7416    impl ::core::convert::From<crate::wire::DirentType> for DirentType {
7417        fn from(wire: crate::wire::DirentType) -> Self {
7418            match u8::from(wire.value) {
7419                0 => Self::Unknown,
7420
7421                4 => Self::Directory,
7422
7423                6 => Self::BlockDevice,
7424
7425                8 => Self::File,
7426
7427                10 => Self::Symlink,
7428
7429                16 => Self::Service,
7430
7431                value => Self::UnknownOrdinal_(value),
7432            }
7433        }
7434    }
7435
7436    impl ::fidl_next::FromWire<crate::wire::DirentType> for DirentType {
7437        #[inline]
7438        fn from_wire(wire: crate::wire::DirentType) -> Self {
7439            Self::from(wire)
7440        }
7441    }
7442
7443    impl ::fidl_next::FromWireRef<crate::wire::DirentType> for DirentType {
7444        #[inline]
7445        fn from_wire_ref(wire: &crate::wire::DirentType) -> Self {
7446            Self::from(*wire)
7447        }
7448    }
7449
7450    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7451    pub struct ExtendedAttributeIteratorGetNextResponse {
7452        pub attributes: ::std::vec::Vec<::std::vec::Vec<u8>>,
7453
7454        pub last: bool,
7455    }
7456
7457    unsafe impl<___E>
7458        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
7459        for ExtendedAttributeIteratorGetNextResponse
7460    where
7461        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7462        ___E: ::fidl_next::Encoder,
7463    {
7464        #[inline]
7465        fn encode(
7466            self,
7467            encoder_: &mut ___E,
7468            out_: &mut ::core::mem::MaybeUninit<
7469                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7470            >,
7471            _: (),
7472        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7473            ::fidl_next::munge! {
7474                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
7475                    attributes,
7476                    last,
7477
7478                } = out_;
7479            }
7480
7481            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
7482
7483            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
7484            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
7485
7486            ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
7487
7488            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
7489
7490            Ok(())
7491        }
7492    }
7493
7494    unsafe impl<'a, ___E>
7495        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
7496        for &'a ExtendedAttributeIteratorGetNextResponse
7497    where
7498        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7499        ___E: ::fidl_next::Encoder,
7500    {
7501        #[inline]
7502        fn encode(
7503            self,
7504            encoder_: &mut ___E,
7505            out_: &mut ::core::mem::MaybeUninit<
7506                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7507            >,
7508            _: (),
7509        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7510            ::fidl_next::munge! {
7511                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
7512                    attributes,
7513                    last,
7514
7515                } = out_;
7516            }
7517
7518            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, (128, (255, ())))?;
7519
7520            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
7521            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
7522
7523            ::fidl_next::Encode::encode(&self.last, encoder_, last, ())?;
7524
7525            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
7526
7527            Ok(())
7528        }
7529    }
7530
7531    unsafe impl<___E>
7532        ::fidl_next::EncodeOption<
7533            ::fidl_next::wire::Box<
7534                'static,
7535                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7536            >,
7537            ___E,
7538        > for ExtendedAttributeIteratorGetNextResponse
7539    where
7540        ___E: ::fidl_next::Encoder + ?Sized,
7541        ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
7542                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7543                ___E,
7544            >,
7545    {
7546        #[inline]
7547        fn encode_option(
7548            this: ::core::option::Option<Self>,
7549            encoder: &mut ___E,
7550            out: &mut ::core::mem::MaybeUninit<
7551                ::fidl_next::wire::Box<
7552                    'static,
7553                    crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7554                >,
7555            >,
7556            _: (),
7557        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7558            if let Some(inner) = this {
7559                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7560                ::fidl_next::wire::Box::encode_present(out);
7561            } else {
7562                ::fidl_next::wire::Box::encode_absent(out);
7563            }
7564
7565            Ok(())
7566        }
7567    }
7568
7569    unsafe impl<'a, ___E>
7570        ::fidl_next::EncodeOption<
7571            ::fidl_next::wire::Box<
7572                'static,
7573                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7574            >,
7575            ___E,
7576        > for &'a ExtendedAttributeIteratorGetNextResponse
7577    where
7578        ___E: ::fidl_next::Encoder + ?Sized,
7579        &'a ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
7580                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7581                ___E,
7582            >,
7583    {
7584        #[inline]
7585        fn encode_option(
7586            this: ::core::option::Option<Self>,
7587            encoder: &mut ___E,
7588            out: &mut ::core::mem::MaybeUninit<
7589                ::fidl_next::wire::Box<
7590                    'static,
7591                    crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7592                >,
7593            >,
7594            _: (),
7595        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7596            if let Some(inner) = this {
7597                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7598                ::fidl_next::wire::Box::encode_present(out);
7599            } else {
7600                ::fidl_next::wire::Box::encode_absent(out);
7601            }
7602
7603            Ok(())
7604        }
7605    }
7606
7607    impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
7608        for ExtendedAttributeIteratorGetNextResponse
7609    {
7610        #[inline]
7611        fn from_wire(wire: crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>) -> Self {
7612            Self {
7613                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
7614
7615                last: ::fidl_next::FromWire::from_wire(wire.last),
7616            }
7617        }
7618    }
7619
7620    impl<'de> ::fidl_next::FromWireRef<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
7621        for ExtendedAttributeIteratorGetNextResponse
7622    {
7623        #[inline]
7624        fn from_wire_ref(
7625            wire: &crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>,
7626        ) -> Self {
7627            Self {
7628                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
7629
7630                last: ::fidl_next::FromWireRef::from_wire_ref(&wire.last),
7631            }
7632        }
7633    }
7634
7635    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7636    #[repr(C)]
7637    pub struct ReadableReadRequest {
7638        pub count: u64,
7639    }
7640
7641    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
7642        for ReadableReadRequest
7643    where
7644        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7645    {
7646        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7647            Self,
7648            crate::wire::ReadableReadRequest,
7649        > = unsafe {
7650            ::fidl_next::CopyOptimization::enable_if(
7651            true
7652
7653                && <
7654                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
7655                >::COPY_OPTIMIZATION.is_enabled()
7656
7657        )
7658        };
7659
7660        #[inline]
7661        fn encode(
7662            self,
7663            encoder_: &mut ___E,
7664            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
7665            _: (),
7666        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7667            ::fidl_next::munge! {
7668                let crate::wire::ReadableReadRequest {
7669                    count,
7670
7671                } = out_;
7672            }
7673
7674            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
7675
7676            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
7677
7678            Ok(())
7679        }
7680    }
7681
7682    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
7683        for &'a ReadableReadRequest
7684    where
7685        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7686    {
7687        #[inline]
7688        fn encode(
7689            self,
7690            encoder_: &mut ___E,
7691            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
7692            _: (),
7693        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7694            ::fidl_next::munge! {
7695                let crate::wire::ReadableReadRequest {
7696                    count,
7697
7698                } = out_;
7699            }
7700
7701            ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
7702
7703            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
7704
7705            Ok(())
7706        }
7707    }
7708
7709    unsafe impl<___E>
7710        ::fidl_next::EncodeOption<
7711            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7712            ___E,
7713        > for ReadableReadRequest
7714    where
7715        ___E: ::fidl_next::Encoder + ?Sized,
7716        ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
7717    {
7718        #[inline]
7719        fn encode_option(
7720            this: ::core::option::Option<Self>,
7721            encoder: &mut ___E,
7722            out: &mut ::core::mem::MaybeUninit<
7723                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7724            >,
7725            _: (),
7726        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7727            if let Some(inner) = this {
7728                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7729                ::fidl_next::wire::Box::encode_present(out);
7730            } else {
7731                ::fidl_next::wire::Box::encode_absent(out);
7732            }
7733
7734            Ok(())
7735        }
7736    }
7737
7738    unsafe impl<'a, ___E>
7739        ::fidl_next::EncodeOption<
7740            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7741            ___E,
7742        > for &'a ReadableReadRequest
7743    where
7744        ___E: ::fidl_next::Encoder + ?Sized,
7745        &'a ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
7746    {
7747        #[inline]
7748        fn encode_option(
7749            this: ::core::option::Option<Self>,
7750            encoder: &mut ___E,
7751            out: &mut ::core::mem::MaybeUninit<
7752                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7753            >,
7754            _: (),
7755        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7756            if let Some(inner) = this {
7757                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7758                ::fidl_next::wire::Box::encode_present(out);
7759            } else {
7760                ::fidl_next::wire::Box::encode_absent(out);
7761            }
7762
7763            Ok(())
7764        }
7765    }
7766
7767    impl ::fidl_next::FromWire<crate::wire::ReadableReadRequest> for ReadableReadRequest {
7768        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7769            crate::wire::ReadableReadRequest,
7770            Self,
7771        > = unsafe {
7772            ::fidl_next::CopyOptimization::enable_if(
7773                true
7774                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
7775                        .is_enabled(),
7776            )
7777        };
7778
7779        #[inline]
7780        fn from_wire(wire: crate::wire::ReadableReadRequest) -> Self {
7781            Self { count: ::fidl_next::FromWire::from_wire(wire.count) }
7782        }
7783    }
7784
7785    impl ::fidl_next::FromWireRef<crate::wire::ReadableReadRequest> for ReadableReadRequest {
7786        #[inline]
7787        fn from_wire_ref(wire: &crate::wire::ReadableReadRequest) -> Self {
7788            Self { count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count) }
7789        }
7790    }
7791
7792    #[doc = " The byte vector type used for read/write operations.\n"]
7793    pub type Transfer = ::std::vec::Vec<u8>;
7794
7795    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7796    pub struct ReadableReadResponse {
7797        pub data: ::std::vec::Vec<u8>,
7798    }
7799
7800    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
7801        for ReadableReadResponse
7802    where
7803        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7804        ___E: ::fidl_next::Encoder,
7805    {
7806        #[inline]
7807        fn encode(
7808            self,
7809            encoder_: &mut ___E,
7810            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
7811            _: (),
7812        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7813            ::fidl_next::munge! {
7814                let crate::wire::ReadableReadResponse {
7815                    data,
7816
7817                } = out_;
7818            }
7819
7820            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
7821
7822            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7823            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7824
7825            Ok(())
7826        }
7827    }
7828
7829    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
7830        for &'a ReadableReadResponse
7831    where
7832        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7833        ___E: ::fidl_next::Encoder,
7834    {
7835        #[inline]
7836        fn encode(
7837            self,
7838            encoder_: &mut ___E,
7839            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
7840            _: (),
7841        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7842            ::fidl_next::munge! {
7843                let crate::wire::ReadableReadResponse {
7844                    data,
7845
7846                } = out_;
7847            }
7848
7849            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
7850
7851            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7852            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7853
7854            Ok(())
7855        }
7856    }
7857
7858    unsafe impl<___E>
7859        ::fidl_next::EncodeOption<
7860            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7861            ___E,
7862        > for ReadableReadResponse
7863    where
7864        ___E: ::fidl_next::Encoder + ?Sized,
7865        ReadableReadResponse: ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
7866    {
7867        #[inline]
7868        fn encode_option(
7869            this: ::core::option::Option<Self>,
7870            encoder: &mut ___E,
7871            out: &mut ::core::mem::MaybeUninit<
7872                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7873            >,
7874            _: (),
7875        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7876            if let Some(inner) = this {
7877                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7878                ::fidl_next::wire::Box::encode_present(out);
7879            } else {
7880                ::fidl_next::wire::Box::encode_absent(out);
7881            }
7882
7883            Ok(())
7884        }
7885    }
7886
7887    unsafe impl<'a, ___E>
7888        ::fidl_next::EncodeOption<
7889            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7890            ___E,
7891        > for &'a ReadableReadResponse
7892    where
7893        ___E: ::fidl_next::Encoder + ?Sized,
7894        &'a ReadableReadResponse:
7895            ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
7896    {
7897        #[inline]
7898        fn encode_option(
7899            this: ::core::option::Option<Self>,
7900            encoder: &mut ___E,
7901            out: &mut ::core::mem::MaybeUninit<
7902                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7903            >,
7904            _: (),
7905        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7906            if let Some(inner) = this {
7907                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7908                ::fidl_next::wire::Box::encode_present(out);
7909            } else {
7910                ::fidl_next::wire::Box::encode_absent(out);
7911            }
7912
7913            Ok(())
7914        }
7915    }
7916
7917    impl<'de> ::fidl_next::FromWire<crate::wire::ReadableReadResponse<'de>> for ReadableReadResponse {
7918        #[inline]
7919        fn from_wire(wire: crate::wire::ReadableReadResponse<'de>) -> Self {
7920            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
7921        }
7922    }
7923
7924    impl<'de> ::fidl_next::FromWireRef<crate::wire::ReadableReadResponse<'de>>
7925        for ReadableReadResponse
7926    {
7927        #[inline]
7928        fn from_wire_ref(wire: &crate::wire::ReadableReadResponse<'de>) -> Self {
7929            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
7930        }
7931    }
7932
7933    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7934    pub struct WritableWriteRequest {
7935        pub data: ::std::vec::Vec<u8>,
7936    }
7937
7938    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
7939        for WritableWriteRequest
7940    where
7941        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7942        ___E: ::fidl_next::Encoder,
7943    {
7944        #[inline]
7945        fn encode(
7946            self,
7947            encoder_: &mut ___E,
7948            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
7949            _: (),
7950        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7951            ::fidl_next::munge! {
7952                let crate::wire::WritableWriteRequest {
7953                    data,
7954
7955                } = out_;
7956            }
7957
7958            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
7959
7960            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7961            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7962
7963            Ok(())
7964        }
7965    }
7966
7967    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
7968        for &'a WritableWriteRequest
7969    where
7970        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7971        ___E: ::fidl_next::Encoder,
7972    {
7973        #[inline]
7974        fn encode(
7975            self,
7976            encoder_: &mut ___E,
7977            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
7978            _: (),
7979        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7980            ::fidl_next::munge! {
7981                let crate::wire::WritableWriteRequest {
7982                    data,
7983
7984                } = out_;
7985            }
7986
7987            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
7988
7989            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7990            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7991
7992            Ok(())
7993        }
7994    }
7995
7996    unsafe impl<___E>
7997        ::fidl_next::EncodeOption<
7998            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
7999            ___E,
8000        > for WritableWriteRequest
8001    where
8002        ___E: ::fidl_next::Encoder + ?Sized,
8003        WritableWriteRequest: ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
8004    {
8005        #[inline]
8006        fn encode_option(
8007            this: ::core::option::Option<Self>,
8008            encoder: &mut ___E,
8009            out: &mut ::core::mem::MaybeUninit<
8010                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8011            >,
8012            _: (),
8013        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8014            if let Some(inner) = this {
8015                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8016                ::fidl_next::wire::Box::encode_present(out);
8017            } else {
8018                ::fidl_next::wire::Box::encode_absent(out);
8019            }
8020
8021            Ok(())
8022        }
8023    }
8024
8025    unsafe impl<'a, ___E>
8026        ::fidl_next::EncodeOption<
8027            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8028            ___E,
8029        > for &'a WritableWriteRequest
8030    where
8031        ___E: ::fidl_next::Encoder + ?Sized,
8032        &'a WritableWriteRequest:
8033            ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
8034    {
8035        #[inline]
8036        fn encode_option(
8037            this: ::core::option::Option<Self>,
8038            encoder: &mut ___E,
8039            out: &mut ::core::mem::MaybeUninit<
8040                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8041            >,
8042            _: (),
8043        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8044            if let Some(inner) = this {
8045                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8046                ::fidl_next::wire::Box::encode_present(out);
8047            } else {
8048                ::fidl_next::wire::Box::encode_absent(out);
8049            }
8050
8051            Ok(())
8052        }
8053    }
8054
8055    impl<'de> ::fidl_next::FromWire<crate::wire::WritableWriteRequest<'de>> for WritableWriteRequest {
8056        #[inline]
8057        fn from_wire(wire: crate::wire::WritableWriteRequest<'de>) -> Self {
8058            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
8059        }
8060    }
8061
8062    impl<'de> ::fidl_next::FromWireRef<crate::wire::WritableWriteRequest<'de>>
8063        for WritableWriteRequest
8064    {
8065        #[inline]
8066        fn from_wire_ref(wire: &crate::wire::WritableWriteRequest<'de>) -> Self {
8067            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
8068        }
8069    }
8070
8071    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8072    #[repr(C)]
8073    pub struct WritableWriteResponse {
8074        pub actual_count: u64,
8075    }
8076
8077    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
8078        for WritableWriteResponse
8079    where
8080        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8081    {
8082        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8083            Self,
8084            crate::wire::WritableWriteResponse,
8085        > = unsafe {
8086            ::fidl_next::CopyOptimization::enable_if(
8087            true
8088
8089                && <
8090                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8091                >::COPY_OPTIMIZATION.is_enabled()
8092
8093        )
8094        };
8095
8096        #[inline]
8097        fn encode(
8098            self,
8099            encoder_: &mut ___E,
8100            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
8101            _: (),
8102        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8103            ::fidl_next::munge! {
8104                let crate::wire::WritableWriteResponse {
8105                    actual_count,
8106
8107                } = out_;
8108            }
8109
8110            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
8111
8112            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
8113
8114            Ok(())
8115        }
8116    }
8117
8118    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
8119        for &'a WritableWriteResponse
8120    where
8121        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8122    {
8123        #[inline]
8124        fn encode(
8125            self,
8126            encoder_: &mut ___E,
8127            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
8128            _: (),
8129        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8130            ::fidl_next::munge! {
8131                let crate::wire::WritableWriteResponse {
8132                    actual_count,
8133
8134                } = out_;
8135            }
8136
8137            ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
8138
8139            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
8140
8141            Ok(())
8142        }
8143    }
8144
8145    unsafe impl<___E>
8146        ::fidl_next::EncodeOption<
8147            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8148            ___E,
8149        > for WritableWriteResponse
8150    where
8151        ___E: ::fidl_next::Encoder + ?Sized,
8152        WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
8153    {
8154        #[inline]
8155        fn encode_option(
8156            this: ::core::option::Option<Self>,
8157            encoder: &mut ___E,
8158            out: &mut ::core::mem::MaybeUninit<
8159                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8160            >,
8161            _: (),
8162        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8163            if let Some(inner) = this {
8164                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8165                ::fidl_next::wire::Box::encode_present(out);
8166            } else {
8167                ::fidl_next::wire::Box::encode_absent(out);
8168            }
8169
8170            Ok(())
8171        }
8172    }
8173
8174    unsafe impl<'a, ___E>
8175        ::fidl_next::EncodeOption<
8176            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8177            ___E,
8178        > for &'a WritableWriteResponse
8179    where
8180        ___E: ::fidl_next::Encoder + ?Sized,
8181        &'a WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
8182    {
8183        #[inline]
8184        fn encode_option(
8185            this: ::core::option::Option<Self>,
8186            encoder: &mut ___E,
8187            out: &mut ::core::mem::MaybeUninit<
8188                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8189            >,
8190            _: (),
8191        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8192            if let Some(inner) = this {
8193                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8194                ::fidl_next::wire::Box::encode_present(out);
8195            } else {
8196                ::fidl_next::wire::Box::encode_absent(out);
8197            }
8198
8199            Ok(())
8200        }
8201    }
8202
8203    impl ::fidl_next::FromWire<crate::wire::WritableWriteResponse> for WritableWriteResponse {
8204        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8205            crate::wire::WritableWriteResponse,
8206            Self,
8207        > = unsafe {
8208            ::fidl_next::CopyOptimization::enable_if(
8209                true
8210                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8211                        .is_enabled(),
8212            )
8213        };
8214
8215        #[inline]
8216        fn from_wire(wire: crate::wire::WritableWriteResponse) -> Self {
8217            Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
8218        }
8219    }
8220
8221    impl ::fidl_next::FromWireRef<crate::wire::WritableWriteResponse> for WritableWriteResponse {
8222        #[inline]
8223        fn from_wire_ref(wire: &crate::wire::WritableWriteResponse) -> Self {
8224            Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
8225        }
8226    }
8227
8228    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8229    pub struct FileSeekRequest {
8230        pub origin: crate::natural::SeekOrigin,
8231
8232        pub offset: i64,
8233    }
8234
8235    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E> for FileSeekRequest
8236    where
8237        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8238    {
8239        #[inline]
8240        fn encode(
8241            self,
8242            encoder_: &mut ___E,
8243            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
8244            _: (),
8245        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8246            ::fidl_next::munge! {
8247                let crate::wire::FileSeekRequest {
8248                    origin,
8249                    offset,
8250
8251                } = out_;
8252            }
8253
8254            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
8255
8256            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
8257
8258            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8259
8260            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8261
8262            Ok(())
8263        }
8264    }
8265
8266    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
8267        for &'a FileSeekRequest
8268    where
8269        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8270    {
8271        #[inline]
8272        fn encode(
8273            self,
8274            encoder_: &mut ___E,
8275            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
8276            _: (),
8277        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8278            ::fidl_next::munge! {
8279                let crate::wire::FileSeekRequest {
8280                    origin,
8281                    offset,
8282
8283                } = out_;
8284            }
8285
8286            ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
8287
8288            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
8289
8290            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8291
8292            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8293
8294            Ok(())
8295        }
8296    }
8297
8298    unsafe impl<___E>
8299        ::fidl_next::EncodeOption<
8300            ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8301            ___E,
8302        > for FileSeekRequest
8303    where
8304        ___E: ::fidl_next::Encoder + ?Sized,
8305        FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
8306    {
8307        #[inline]
8308        fn encode_option(
8309            this: ::core::option::Option<Self>,
8310            encoder: &mut ___E,
8311            out: &mut ::core::mem::MaybeUninit<
8312                ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8313            >,
8314            _: (),
8315        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8316            if let Some(inner) = this {
8317                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8318                ::fidl_next::wire::Box::encode_present(out);
8319            } else {
8320                ::fidl_next::wire::Box::encode_absent(out);
8321            }
8322
8323            Ok(())
8324        }
8325    }
8326
8327    unsafe impl<'a, ___E>
8328        ::fidl_next::EncodeOption<
8329            ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8330            ___E,
8331        > for &'a FileSeekRequest
8332    where
8333        ___E: ::fidl_next::Encoder + ?Sized,
8334        &'a FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
8335    {
8336        #[inline]
8337        fn encode_option(
8338            this: ::core::option::Option<Self>,
8339            encoder: &mut ___E,
8340            out: &mut ::core::mem::MaybeUninit<
8341                ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8342            >,
8343            _: (),
8344        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8345            if let Some(inner) = this {
8346                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8347                ::fidl_next::wire::Box::encode_present(out);
8348            } else {
8349                ::fidl_next::wire::Box::encode_absent(out);
8350            }
8351
8352            Ok(())
8353        }
8354    }
8355
8356    impl ::fidl_next::FromWire<crate::wire::FileSeekRequest> for FileSeekRequest {
8357        #[inline]
8358        fn from_wire(wire: crate::wire::FileSeekRequest) -> Self {
8359            Self {
8360                origin: ::fidl_next::FromWire::from_wire(wire.origin),
8361
8362                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8363            }
8364        }
8365    }
8366
8367    impl ::fidl_next::FromWireRef<crate::wire::FileSeekRequest> for FileSeekRequest {
8368        #[inline]
8369        fn from_wire_ref(wire: &crate::wire::FileSeekRequest) -> Self {
8370            Self {
8371                origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
8372
8373                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
8374            }
8375        }
8376    }
8377
8378    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8379    #[repr(C)]
8380    pub struct FileSeekResponse {
8381        pub offset_from_start: u64,
8382    }
8383
8384    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E> for FileSeekResponse
8385    where
8386        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8387    {
8388        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8389            Self,
8390            crate::wire::FileSeekResponse,
8391        > = unsafe {
8392            ::fidl_next::CopyOptimization::enable_if(
8393            true
8394
8395                && <
8396                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8397                >::COPY_OPTIMIZATION.is_enabled()
8398
8399        )
8400        };
8401
8402        #[inline]
8403        fn encode(
8404            self,
8405            encoder_: &mut ___E,
8406            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
8407            _: (),
8408        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8409            ::fidl_next::munge! {
8410                let crate::wire::FileSeekResponse {
8411                    offset_from_start,
8412
8413                } = out_;
8414            }
8415
8416            ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
8417
8418            let mut _field =
8419                unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
8420
8421            Ok(())
8422        }
8423    }
8424
8425    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
8426        for &'a FileSeekResponse
8427    where
8428        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8429    {
8430        #[inline]
8431        fn encode(
8432            self,
8433            encoder_: &mut ___E,
8434            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
8435            _: (),
8436        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8437            ::fidl_next::munge! {
8438                let crate::wire::FileSeekResponse {
8439                    offset_from_start,
8440
8441                } = out_;
8442            }
8443
8444            ::fidl_next::Encode::encode(&self.offset_from_start, encoder_, offset_from_start, ())?;
8445
8446            let mut _field =
8447                unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
8448
8449            Ok(())
8450        }
8451    }
8452
8453    unsafe impl<___E>
8454        ::fidl_next::EncodeOption<
8455            ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8456            ___E,
8457        > for FileSeekResponse
8458    where
8459        ___E: ::fidl_next::Encoder + ?Sized,
8460        FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
8461    {
8462        #[inline]
8463        fn encode_option(
8464            this: ::core::option::Option<Self>,
8465            encoder: &mut ___E,
8466            out: &mut ::core::mem::MaybeUninit<
8467                ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8468            >,
8469            _: (),
8470        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8471            if let Some(inner) = this {
8472                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8473                ::fidl_next::wire::Box::encode_present(out);
8474            } else {
8475                ::fidl_next::wire::Box::encode_absent(out);
8476            }
8477
8478            Ok(())
8479        }
8480    }
8481
8482    unsafe impl<'a, ___E>
8483        ::fidl_next::EncodeOption<
8484            ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8485            ___E,
8486        > for &'a FileSeekResponse
8487    where
8488        ___E: ::fidl_next::Encoder + ?Sized,
8489        &'a FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
8490    {
8491        #[inline]
8492        fn encode_option(
8493            this: ::core::option::Option<Self>,
8494            encoder: &mut ___E,
8495            out: &mut ::core::mem::MaybeUninit<
8496                ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8497            >,
8498            _: (),
8499        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8500            if let Some(inner) = this {
8501                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8502                ::fidl_next::wire::Box::encode_present(out);
8503            } else {
8504                ::fidl_next::wire::Box::encode_absent(out);
8505            }
8506
8507            Ok(())
8508        }
8509    }
8510
8511    impl ::fidl_next::FromWire<crate::wire::FileSeekResponse> for FileSeekResponse {
8512        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8513            crate::wire::FileSeekResponse,
8514            Self,
8515        > = unsafe {
8516            ::fidl_next::CopyOptimization::enable_if(
8517                true
8518                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8519                        .is_enabled(),
8520            )
8521        };
8522
8523        #[inline]
8524        fn from_wire(wire: crate::wire::FileSeekResponse) -> Self {
8525            Self { offset_from_start: ::fidl_next::FromWire::from_wire(wire.offset_from_start) }
8526        }
8527    }
8528
8529    impl ::fidl_next::FromWireRef<crate::wire::FileSeekResponse> for FileSeekResponse {
8530        #[inline]
8531        fn from_wire_ref(wire: &crate::wire::FileSeekResponse) -> Self {
8532            Self {
8533                offset_from_start: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset_from_start),
8534            }
8535        }
8536    }
8537
8538    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8539    #[repr(C)]
8540    pub struct FileReadAtRequest {
8541        pub count: u64,
8542
8543        pub offset: u64,
8544    }
8545
8546    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E> for FileReadAtRequest
8547    where
8548        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8549    {
8550        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8551            Self,
8552            crate::wire::FileReadAtRequest,
8553        > = unsafe {
8554            ::fidl_next::CopyOptimization::enable_if(
8555            true
8556
8557                && <
8558                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8559                >::COPY_OPTIMIZATION.is_enabled()
8560
8561                && <
8562                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8563                >::COPY_OPTIMIZATION.is_enabled()
8564
8565        )
8566        };
8567
8568        #[inline]
8569        fn encode(
8570            self,
8571            encoder_: &mut ___E,
8572            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
8573            _: (),
8574        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8575            ::fidl_next::munge! {
8576                let crate::wire::FileReadAtRequest {
8577                    count,
8578                    offset,
8579
8580                } = out_;
8581            }
8582
8583            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
8584
8585            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
8586
8587            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8588
8589            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8590
8591            Ok(())
8592        }
8593    }
8594
8595    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
8596        for &'a FileReadAtRequest
8597    where
8598        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8599    {
8600        #[inline]
8601        fn encode(
8602            self,
8603            encoder_: &mut ___E,
8604            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
8605            _: (),
8606        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8607            ::fidl_next::munge! {
8608                let crate::wire::FileReadAtRequest {
8609                    count,
8610                    offset,
8611
8612                } = out_;
8613            }
8614
8615            ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
8616
8617            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
8618
8619            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8620
8621            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8622
8623            Ok(())
8624        }
8625    }
8626
8627    unsafe impl<___E>
8628        ::fidl_next::EncodeOption<
8629            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8630            ___E,
8631        > for FileReadAtRequest
8632    where
8633        ___E: ::fidl_next::Encoder + ?Sized,
8634        FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
8635    {
8636        #[inline]
8637        fn encode_option(
8638            this: ::core::option::Option<Self>,
8639            encoder: &mut ___E,
8640            out: &mut ::core::mem::MaybeUninit<
8641                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8642            >,
8643            _: (),
8644        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8645            if let Some(inner) = this {
8646                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8647                ::fidl_next::wire::Box::encode_present(out);
8648            } else {
8649                ::fidl_next::wire::Box::encode_absent(out);
8650            }
8651
8652            Ok(())
8653        }
8654    }
8655
8656    unsafe impl<'a, ___E>
8657        ::fidl_next::EncodeOption<
8658            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8659            ___E,
8660        > for &'a FileReadAtRequest
8661    where
8662        ___E: ::fidl_next::Encoder + ?Sized,
8663        &'a FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
8664    {
8665        #[inline]
8666        fn encode_option(
8667            this: ::core::option::Option<Self>,
8668            encoder: &mut ___E,
8669            out: &mut ::core::mem::MaybeUninit<
8670                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8671            >,
8672            _: (),
8673        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8674            if let Some(inner) = this {
8675                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8676                ::fidl_next::wire::Box::encode_present(out);
8677            } else {
8678                ::fidl_next::wire::Box::encode_absent(out);
8679            }
8680
8681            Ok(())
8682        }
8683    }
8684
8685    impl ::fidl_next::FromWire<crate::wire::FileReadAtRequest> for FileReadAtRequest {
8686        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8687            crate::wire::FileReadAtRequest,
8688            Self,
8689        > = unsafe {
8690            ::fidl_next::CopyOptimization::enable_if(
8691                true
8692                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8693                        .is_enabled()
8694                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8695                        .is_enabled(),
8696            )
8697        };
8698
8699        #[inline]
8700        fn from_wire(wire: crate::wire::FileReadAtRequest) -> Self {
8701            Self {
8702                count: ::fidl_next::FromWire::from_wire(wire.count),
8703
8704                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8705            }
8706        }
8707    }
8708
8709    impl ::fidl_next::FromWireRef<crate::wire::FileReadAtRequest> for FileReadAtRequest {
8710        #[inline]
8711        fn from_wire_ref(wire: &crate::wire::FileReadAtRequest) -> Self {
8712            Self {
8713                count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count),
8714
8715                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
8716            }
8717        }
8718    }
8719
8720    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8721    pub struct FileReadAtResponse {
8722        pub data: ::std::vec::Vec<u8>,
8723    }
8724
8725    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
8726        for FileReadAtResponse
8727    where
8728        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8729        ___E: ::fidl_next::Encoder,
8730    {
8731        #[inline]
8732        fn encode(
8733            self,
8734            encoder_: &mut ___E,
8735            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
8736            _: (),
8737        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8738            ::fidl_next::munge! {
8739                let crate::wire::FileReadAtResponse {
8740                    data,
8741
8742                } = out_;
8743            }
8744
8745            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
8746
8747            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8748            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8749
8750            Ok(())
8751        }
8752    }
8753
8754    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
8755        for &'a FileReadAtResponse
8756    where
8757        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8758        ___E: ::fidl_next::Encoder,
8759    {
8760        #[inline]
8761        fn encode(
8762            self,
8763            encoder_: &mut ___E,
8764            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
8765            _: (),
8766        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8767            ::fidl_next::munge! {
8768                let crate::wire::FileReadAtResponse {
8769                    data,
8770
8771                } = out_;
8772            }
8773
8774            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
8775
8776            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8777            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8778
8779            Ok(())
8780        }
8781    }
8782
8783    unsafe impl<___E>
8784        ::fidl_next::EncodeOption<
8785            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8786            ___E,
8787        > for FileReadAtResponse
8788    where
8789        ___E: ::fidl_next::Encoder + ?Sized,
8790        FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
8791    {
8792        #[inline]
8793        fn encode_option(
8794            this: ::core::option::Option<Self>,
8795            encoder: &mut ___E,
8796            out: &mut ::core::mem::MaybeUninit<
8797                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8798            >,
8799            _: (),
8800        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8801            if let Some(inner) = this {
8802                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8803                ::fidl_next::wire::Box::encode_present(out);
8804            } else {
8805                ::fidl_next::wire::Box::encode_absent(out);
8806            }
8807
8808            Ok(())
8809        }
8810    }
8811
8812    unsafe impl<'a, ___E>
8813        ::fidl_next::EncodeOption<
8814            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8815            ___E,
8816        > for &'a FileReadAtResponse
8817    where
8818        ___E: ::fidl_next::Encoder + ?Sized,
8819        &'a FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
8820    {
8821        #[inline]
8822        fn encode_option(
8823            this: ::core::option::Option<Self>,
8824            encoder: &mut ___E,
8825            out: &mut ::core::mem::MaybeUninit<
8826                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8827            >,
8828            _: (),
8829        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8830            if let Some(inner) = this {
8831                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8832                ::fidl_next::wire::Box::encode_present(out);
8833            } else {
8834                ::fidl_next::wire::Box::encode_absent(out);
8835            }
8836
8837            Ok(())
8838        }
8839    }
8840
8841    impl<'de> ::fidl_next::FromWire<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
8842        #[inline]
8843        fn from_wire(wire: crate::wire::FileReadAtResponse<'de>) -> Self {
8844            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
8845        }
8846    }
8847
8848    impl<'de> ::fidl_next::FromWireRef<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
8849        #[inline]
8850        fn from_wire_ref(wire: &crate::wire::FileReadAtResponse<'de>) -> Self {
8851            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
8852        }
8853    }
8854
8855    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8856    pub struct FileWriteAtRequest {
8857        pub data: ::std::vec::Vec<u8>,
8858
8859        pub offset: u64,
8860    }
8861
8862    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
8863        for FileWriteAtRequest
8864    where
8865        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8866        ___E: ::fidl_next::Encoder,
8867    {
8868        #[inline]
8869        fn encode(
8870            self,
8871            encoder_: &mut ___E,
8872            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
8873            _: (),
8874        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8875            ::fidl_next::munge! {
8876                let crate::wire::FileWriteAtRequest {
8877                    data,
8878                    offset,
8879
8880                } = out_;
8881            }
8882
8883            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
8884
8885            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8886            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8887
8888            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8889
8890            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8891
8892            Ok(())
8893        }
8894    }
8895
8896    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
8897        for &'a FileWriteAtRequest
8898    where
8899        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8900        ___E: ::fidl_next::Encoder,
8901    {
8902        #[inline]
8903        fn encode(
8904            self,
8905            encoder_: &mut ___E,
8906            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
8907            _: (),
8908        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8909            ::fidl_next::munge! {
8910                let crate::wire::FileWriteAtRequest {
8911                    data,
8912                    offset,
8913
8914                } = out_;
8915            }
8916
8917            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
8918
8919            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8920            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8921
8922            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8923
8924            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8925
8926            Ok(())
8927        }
8928    }
8929
8930    unsafe impl<___E>
8931        ::fidl_next::EncodeOption<
8932            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8933            ___E,
8934        > for FileWriteAtRequest
8935    where
8936        ___E: ::fidl_next::Encoder + ?Sized,
8937        FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
8938    {
8939        #[inline]
8940        fn encode_option(
8941            this: ::core::option::Option<Self>,
8942            encoder: &mut ___E,
8943            out: &mut ::core::mem::MaybeUninit<
8944                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8945            >,
8946            _: (),
8947        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8948            if let Some(inner) = this {
8949                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8950                ::fidl_next::wire::Box::encode_present(out);
8951            } else {
8952                ::fidl_next::wire::Box::encode_absent(out);
8953            }
8954
8955            Ok(())
8956        }
8957    }
8958
8959    unsafe impl<'a, ___E>
8960        ::fidl_next::EncodeOption<
8961            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8962            ___E,
8963        > for &'a FileWriteAtRequest
8964    where
8965        ___E: ::fidl_next::Encoder + ?Sized,
8966        &'a FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
8967    {
8968        #[inline]
8969        fn encode_option(
8970            this: ::core::option::Option<Self>,
8971            encoder: &mut ___E,
8972            out: &mut ::core::mem::MaybeUninit<
8973                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8974            >,
8975            _: (),
8976        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8977            if let Some(inner) = this {
8978                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8979                ::fidl_next::wire::Box::encode_present(out);
8980            } else {
8981                ::fidl_next::wire::Box::encode_absent(out);
8982            }
8983
8984            Ok(())
8985        }
8986    }
8987
8988    impl<'de> ::fidl_next::FromWire<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
8989        #[inline]
8990        fn from_wire(wire: crate::wire::FileWriteAtRequest<'de>) -> Self {
8991            Self {
8992                data: ::fidl_next::FromWire::from_wire(wire.data),
8993
8994                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8995            }
8996        }
8997    }
8998
8999    impl<'de> ::fidl_next::FromWireRef<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
9000        #[inline]
9001        fn from_wire_ref(wire: &crate::wire::FileWriteAtRequest<'de>) -> Self {
9002            Self {
9003                data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data),
9004
9005                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
9006            }
9007        }
9008    }
9009
9010    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9011    #[repr(C)]
9012    pub struct FileWriteAtResponse {
9013        pub actual_count: u64,
9014    }
9015
9016    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
9017        for FileWriteAtResponse
9018    where
9019        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9020    {
9021        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9022            Self,
9023            crate::wire::FileWriteAtResponse,
9024        > = unsafe {
9025            ::fidl_next::CopyOptimization::enable_if(
9026            true
9027
9028                && <
9029                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9030                >::COPY_OPTIMIZATION.is_enabled()
9031
9032        )
9033        };
9034
9035        #[inline]
9036        fn encode(
9037            self,
9038            encoder_: &mut ___E,
9039            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
9040            _: (),
9041        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9042            ::fidl_next::munge! {
9043                let crate::wire::FileWriteAtResponse {
9044                    actual_count,
9045
9046                } = out_;
9047            }
9048
9049            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
9050
9051            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9052
9053            Ok(())
9054        }
9055    }
9056
9057    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
9058        for &'a FileWriteAtResponse
9059    where
9060        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9061    {
9062        #[inline]
9063        fn encode(
9064            self,
9065            encoder_: &mut ___E,
9066            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
9067            _: (),
9068        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9069            ::fidl_next::munge! {
9070                let crate::wire::FileWriteAtResponse {
9071                    actual_count,
9072
9073                } = out_;
9074            }
9075
9076            ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
9077
9078            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9079
9080            Ok(())
9081        }
9082    }
9083
9084    unsafe impl<___E>
9085        ::fidl_next::EncodeOption<
9086            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9087            ___E,
9088        > for FileWriteAtResponse
9089    where
9090        ___E: ::fidl_next::Encoder + ?Sized,
9091        FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
9092    {
9093        #[inline]
9094        fn encode_option(
9095            this: ::core::option::Option<Self>,
9096            encoder: &mut ___E,
9097            out: &mut ::core::mem::MaybeUninit<
9098                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9099            >,
9100            _: (),
9101        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9102            if let Some(inner) = this {
9103                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9104                ::fidl_next::wire::Box::encode_present(out);
9105            } else {
9106                ::fidl_next::wire::Box::encode_absent(out);
9107            }
9108
9109            Ok(())
9110        }
9111    }
9112
9113    unsafe impl<'a, ___E>
9114        ::fidl_next::EncodeOption<
9115            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9116            ___E,
9117        > for &'a FileWriteAtResponse
9118    where
9119        ___E: ::fidl_next::Encoder + ?Sized,
9120        &'a FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
9121    {
9122        #[inline]
9123        fn encode_option(
9124            this: ::core::option::Option<Self>,
9125            encoder: &mut ___E,
9126            out: &mut ::core::mem::MaybeUninit<
9127                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9128            >,
9129            _: (),
9130        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9131            if let Some(inner) = this {
9132                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9133                ::fidl_next::wire::Box::encode_present(out);
9134            } else {
9135                ::fidl_next::wire::Box::encode_absent(out);
9136            }
9137
9138            Ok(())
9139        }
9140    }
9141
9142    impl ::fidl_next::FromWire<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
9143        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9144            crate::wire::FileWriteAtResponse,
9145            Self,
9146        > = unsafe {
9147            ::fidl_next::CopyOptimization::enable_if(
9148                true
9149                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9150                        .is_enabled(),
9151            )
9152        };
9153
9154        #[inline]
9155        fn from_wire(wire: crate::wire::FileWriteAtResponse) -> Self {
9156            Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
9157        }
9158    }
9159
9160    impl ::fidl_next::FromWireRef<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
9161        #[inline]
9162        fn from_wire_ref(wire: &crate::wire::FileWriteAtResponse) -> Self {
9163            Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
9164        }
9165    }
9166
9167    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9168    #[repr(C)]
9169    pub struct FileResizeRequest {
9170        pub length: u64,
9171    }
9172
9173    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E> for FileResizeRequest
9174    where
9175        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9176    {
9177        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9178            Self,
9179            crate::wire::FileResizeRequest,
9180        > = unsafe {
9181            ::fidl_next::CopyOptimization::enable_if(
9182            true
9183
9184                && <
9185                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9186                >::COPY_OPTIMIZATION.is_enabled()
9187
9188        )
9189        };
9190
9191        #[inline]
9192        fn encode(
9193            self,
9194            encoder_: &mut ___E,
9195            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
9196            _: (),
9197        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9198            ::fidl_next::munge! {
9199                let crate::wire::FileResizeRequest {
9200                    length,
9201
9202                } = out_;
9203            }
9204
9205            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
9206
9207            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
9208
9209            Ok(())
9210        }
9211    }
9212
9213    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
9214        for &'a FileResizeRequest
9215    where
9216        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9217    {
9218        #[inline]
9219        fn encode(
9220            self,
9221            encoder_: &mut ___E,
9222            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
9223            _: (),
9224        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9225            ::fidl_next::munge! {
9226                let crate::wire::FileResizeRequest {
9227                    length,
9228
9229                } = out_;
9230            }
9231
9232            ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
9233
9234            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
9235
9236            Ok(())
9237        }
9238    }
9239
9240    unsafe impl<___E>
9241        ::fidl_next::EncodeOption<
9242            ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9243            ___E,
9244        > for FileResizeRequest
9245    where
9246        ___E: ::fidl_next::Encoder + ?Sized,
9247        FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
9248    {
9249        #[inline]
9250        fn encode_option(
9251            this: ::core::option::Option<Self>,
9252            encoder: &mut ___E,
9253            out: &mut ::core::mem::MaybeUninit<
9254                ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9255            >,
9256            _: (),
9257        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9258            if let Some(inner) = this {
9259                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9260                ::fidl_next::wire::Box::encode_present(out);
9261            } else {
9262                ::fidl_next::wire::Box::encode_absent(out);
9263            }
9264
9265            Ok(())
9266        }
9267    }
9268
9269    unsafe impl<'a, ___E>
9270        ::fidl_next::EncodeOption<
9271            ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9272            ___E,
9273        > for &'a FileResizeRequest
9274    where
9275        ___E: ::fidl_next::Encoder + ?Sized,
9276        &'a FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
9277    {
9278        #[inline]
9279        fn encode_option(
9280            this: ::core::option::Option<Self>,
9281            encoder: &mut ___E,
9282            out: &mut ::core::mem::MaybeUninit<
9283                ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9284            >,
9285            _: (),
9286        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9287            if let Some(inner) = this {
9288                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9289                ::fidl_next::wire::Box::encode_present(out);
9290            } else {
9291                ::fidl_next::wire::Box::encode_absent(out);
9292            }
9293
9294            Ok(())
9295        }
9296    }
9297
9298    impl ::fidl_next::FromWire<crate::wire::FileResizeRequest> for FileResizeRequest {
9299        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9300            crate::wire::FileResizeRequest,
9301            Self,
9302        > = unsafe {
9303            ::fidl_next::CopyOptimization::enable_if(
9304                true
9305                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9306                        .is_enabled(),
9307            )
9308        };
9309
9310        #[inline]
9311        fn from_wire(wire: crate::wire::FileResizeRequest) -> Self {
9312            Self { length: ::fidl_next::FromWire::from_wire(wire.length) }
9313        }
9314    }
9315
9316    impl ::fidl_next::FromWireRef<crate::wire::FileResizeRequest> for FileResizeRequest {
9317        #[inline]
9318        fn from_wire_ref(wire: &crate::wire::FileResizeRequest) -> Self {
9319            Self { length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length) }
9320        }
9321    }
9322
9323    pub type FileResizeResponse = ();
9324
9325    ::fidl_next::bitflags::bitflags! {
9326        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct VmoFlags: u32 {
9327            #[doc = " Requests that the VMO be readable.\n"]const READ = 1;
9328            #[doc = " Requests that the VMO be writable.\n"]const WRITE = 2;
9329            #[doc = " Request that the VMO be executable.\n"]const EXECUTE = 4;
9330            #[doc = " Require a copy-on-write clone of the underlying VMO. The request\n should fail if the VMO cannot be cloned. May not be supplied\n with `SHARED_BUFFER`.\n\n A private clone uses at least the guarantees of the\n `ZX_VMO_CHILD_SNAPSHOT_AT_LEAST_ON_WRITE` flag to\n `zx_vmo_create_child()`. This means that the returned VMO will\n be copy-on-write (if `WRITE` is requested) but that it may or\n may not reflect subsequent content changes to the underlying\n file. The returned VMO will not reflect size changes to the\n file. These semantics match those of the POSIX `mmap()`\n `MAP_PRIVATE` flag.\n\n In some cases, clients requiring a guaranteed snapshot of the\n file can use `SHARED_BUFFER` and then use\n `zx_vmo_create_child()` with `ZX_VMO_CHILD_SNAPSHOT`. However,\n in addition to cases where the implementation can\'t return a\n `SHARED_BUFFER`, creating a full snapshot will fail if the VMO\n is attached to the pager. Since most filesystems will use the\n paging system, the full snapshot approach should only be used in\n specific cases where the client is talking to a known server.\n"]const PRIVATE_CLONE = 65536;
9331            #[doc = " Require a VMO that provides direct access to the contents of the\n file\'s underlying VMO. The request should fail if such a VMO\n cannot be provided. May not be supplied with `PRIVATE_CLONE`.\n\n The returned VMO may not be resizable even when `WRITE` access is\n requested. In this case, [`File.Resize`] should be used to resize\n the file.\n"]const SHARED_BUFFER = 131072;
9332
9333        }
9334    }
9335
9336    unsafe impl<___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for VmoFlags
9337    where
9338        ___E: ?Sized,
9339    {
9340        #[inline]
9341        fn encode(
9342            self,
9343            encoder: &mut ___E,
9344            out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
9345            _: (),
9346        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9347            ::fidl_next::Encode::encode(&self, encoder, out, ())
9348        }
9349    }
9350
9351    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for &'a VmoFlags
9352    where
9353        ___E: ?Sized,
9354    {
9355        #[inline]
9356        fn encode(
9357            self,
9358            _: &mut ___E,
9359            out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
9360            _: (),
9361        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9362            ::fidl_next::munge!(let crate::wire::VmoFlags { value } = out);
9363
9364            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
9365                return Err(::fidl_next::EncodeError::InvalidStrictBits);
9366            }
9367
9368            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
9369            Ok(())
9370        }
9371    }
9372
9373    impl ::core::convert::From<crate::wire::VmoFlags> for VmoFlags {
9374        fn from(wire: crate::wire::VmoFlags) -> Self {
9375            Self::from_bits_retain(u32::from(wire.value))
9376        }
9377    }
9378
9379    impl ::fidl_next::FromWire<crate::wire::VmoFlags> for VmoFlags {
9380        #[inline]
9381        fn from_wire(wire: crate::wire::VmoFlags) -> Self {
9382            Self::from(wire)
9383        }
9384    }
9385
9386    impl ::fidl_next::FromWireRef<crate::wire::VmoFlags> for VmoFlags {
9387        #[inline]
9388        fn from_wire_ref(wire: &crate::wire::VmoFlags) -> Self {
9389            Self::from(*wire)
9390        }
9391    }
9392
9393    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9394    #[repr(C)]
9395    pub struct FileGetBackingMemoryRequest {
9396        pub flags: crate::natural::VmoFlags,
9397    }
9398
9399    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
9400        for FileGetBackingMemoryRequest
9401    where
9402        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9403    {
9404        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9405            Self,
9406            crate::wire::FileGetBackingMemoryRequest,
9407        > = unsafe {
9408            ::fidl_next::CopyOptimization::enable_if(
9409                true && <crate::natural::VmoFlags as ::fidl_next::Encode<
9410                    crate::wire::VmoFlags,
9411                    ___E,
9412                >>::COPY_OPTIMIZATION
9413                    .is_enabled(),
9414            )
9415        };
9416
9417        #[inline]
9418        fn encode(
9419            self,
9420            encoder_: &mut ___E,
9421            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
9422            _: (),
9423        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9424            ::fidl_next::munge! {
9425                let crate::wire::FileGetBackingMemoryRequest {
9426                    flags,
9427
9428                } = out_;
9429            }
9430
9431            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
9432
9433            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
9434
9435            Ok(())
9436        }
9437    }
9438
9439    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
9440        for &'a FileGetBackingMemoryRequest
9441    where
9442        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9443    {
9444        #[inline]
9445        fn encode(
9446            self,
9447            encoder_: &mut ___E,
9448            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
9449            _: (),
9450        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9451            ::fidl_next::munge! {
9452                let crate::wire::FileGetBackingMemoryRequest {
9453                    flags,
9454
9455                } = out_;
9456            }
9457
9458            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
9459
9460            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
9461
9462            Ok(())
9463        }
9464    }
9465
9466    unsafe impl<___E>
9467        ::fidl_next::EncodeOption<
9468            ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9469            ___E,
9470        > for FileGetBackingMemoryRequest
9471    where
9472        ___E: ::fidl_next::Encoder + ?Sized,
9473        FileGetBackingMemoryRequest:
9474            ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
9475    {
9476        #[inline]
9477        fn encode_option(
9478            this: ::core::option::Option<Self>,
9479            encoder: &mut ___E,
9480            out: &mut ::core::mem::MaybeUninit<
9481                ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9482            >,
9483            _: (),
9484        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9485            if let Some(inner) = this {
9486                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9487                ::fidl_next::wire::Box::encode_present(out);
9488            } else {
9489                ::fidl_next::wire::Box::encode_absent(out);
9490            }
9491
9492            Ok(())
9493        }
9494    }
9495
9496    unsafe impl<'a, ___E>
9497        ::fidl_next::EncodeOption<
9498            ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9499            ___E,
9500        > for &'a FileGetBackingMemoryRequest
9501    where
9502        ___E: ::fidl_next::Encoder + ?Sized,
9503        &'a FileGetBackingMemoryRequest:
9504            ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
9505    {
9506        #[inline]
9507        fn encode_option(
9508            this: ::core::option::Option<Self>,
9509            encoder: &mut ___E,
9510            out: &mut ::core::mem::MaybeUninit<
9511                ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9512            >,
9513            _: (),
9514        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9515            if let Some(inner) = this {
9516                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9517                ::fidl_next::wire::Box::encode_present(out);
9518            } else {
9519                ::fidl_next::wire::Box::encode_absent(out);
9520            }
9521
9522            Ok(())
9523        }
9524    }
9525
9526    impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryRequest>
9527        for FileGetBackingMemoryRequest
9528    {
9529        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9530            crate::wire::FileGetBackingMemoryRequest,
9531            Self,
9532        > = unsafe {
9533            ::fidl_next::CopyOptimization::enable_if(
9534                true && <crate::natural::VmoFlags as ::fidl_next::FromWire<
9535                    crate::wire::VmoFlags,
9536                >>::COPY_OPTIMIZATION
9537                    .is_enabled(),
9538            )
9539        };
9540
9541        #[inline]
9542        fn from_wire(wire: crate::wire::FileGetBackingMemoryRequest) -> Self {
9543            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
9544        }
9545    }
9546
9547    impl ::fidl_next::FromWireRef<crate::wire::FileGetBackingMemoryRequest>
9548        for FileGetBackingMemoryRequest
9549    {
9550        #[inline]
9551        fn from_wire_ref(wire: &crate::wire::FileGetBackingMemoryRequest) -> Self {
9552            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
9553        }
9554    }
9555
9556    pub type LinkableLinkIntoResponse = ();
9557
9558    pub type FileAllocateResponse = ();
9559
9560    pub type FileEnableVerityResponse = ();
9561
9562    ::fidl_next::bitflags::bitflags! {
9563        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct FileSignal: u32 {
9564            #[doc = " Indicates the file is ready for reading.\n"]const READABLE = 16777216;
9565            #[doc = " Indicates the file is ready for writing.\n"]const WRITABLE = 33554432;
9566
9567        }
9568    }
9569
9570    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for FileSignal
9571    where
9572        ___E: ?Sized,
9573    {
9574        #[inline]
9575        fn encode(
9576            self,
9577            encoder: &mut ___E,
9578            out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
9579            _: (),
9580        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9581            ::fidl_next::Encode::encode(&self, encoder, out, ())
9582        }
9583    }
9584
9585    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for &'a FileSignal
9586    where
9587        ___E: ?Sized,
9588    {
9589        #[inline]
9590        fn encode(
9591            self,
9592            _: &mut ___E,
9593            out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
9594            _: (),
9595        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9596            ::fidl_next::munge!(let crate::wire::FileSignal { value } = out);
9597
9598            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
9599                return Err(::fidl_next::EncodeError::InvalidStrictBits);
9600            }
9601
9602            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
9603            Ok(())
9604        }
9605    }
9606
9607    impl ::core::convert::From<crate::wire::FileSignal> for FileSignal {
9608        fn from(wire: crate::wire::FileSignal) -> Self {
9609            Self::from_bits_retain(u32::from(wire.value))
9610        }
9611    }
9612
9613    impl ::fidl_next::FromWire<crate::wire::FileSignal> for FileSignal {
9614        #[inline]
9615        fn from_wire(wire: crate::wire::FileSignal) -> Self {
9616            Self::from(wire)
9617        }
9618    }
9619
9620    impl ::fidl_next::FromWireRef<crate::wire::FileSignal> for FileSignal {
9621        #[inline]
9622        fn from_wire_ref(wire: &crate::wire::FileSignal) -> Self {
9623            Self::from(*wire)
9624        }
9625    }
9626
9627    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9628    #[repr(C)]
9629    pub struct FilesystemInfo {
9630        pub total_bytes: u64,
9631
9632        pub used_bytes: u64,
9633
9634        pub total_nodes: u64,
9635
9636        pub used_nodes: u64,
9637
9638        pub free_shared_pool_bytes: u64,
9639
9640        pub fs_id: u64,
9641
9642        pub block_size: u32,
9643
9644        pub max_filename_size: u32,
9645
9646        pub fs_type: u32,
9647
9648        pub padding: u32,
9649
9650        pub name: [i8; 32],
9651    }
9652
9653    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for FilesystemInfo
9654    where
9655        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9656    {
9657        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FilesystemInfo> = unsafe {
9658            ::fidl_next::CopyOptimization::enable_if(
9659            true
9660
9661                && <
9662                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9663                >::COPY_OPTIMIZATION.is_enabled()
9664
9665                && <
9666                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9667                >::COPY_OPTIMIZATION.is_enabled()
9668
9669                && <
9670                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9671                >::COPY_OPTIMIZATION.is_enabled()
9672
9673                && <
9674                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9675                >::COPY_OPTIMIZATION.is_enabled()
9676
9677                && <
9678                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9679                >::COPY_OPTIMIZATION.is_enabled()
9680
9681                && <
9682                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9683                >::COPY_OPTIMIZATION.is_enabled()
9684
9685                && <
9686                    u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
9687                >::COPY_OPTIMIZATION.is_enabled()
9688
9689                && <
9690                    u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
9691                >::COPY_OPTIMIZATION.is_enabled()
9692
9693                && <
9694                    u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
9695                >::COPY_OPTIMIZATION.is_enabled()
9696
9697                && <
9698                    u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
9699                >::COPY_OPTIMIZATION.is_enabled()
9700
9701                && <
9702                    [i8; 32] as ::fidl_next::Encode<[i8; 32], ___E>
9703                >::COPY_OPTIMIZATION.is_enabled()
9704
9705        )
9706        };
9707
9708        #[inline]
9709        fn encode(
9710            self,
9711            encoder_: &mut ___E,
9712            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
9713            _: (),
9714        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9715            ::fidl_next::munge! {
9716                let crate::wire::FilesystemInfo {
9717                    total_bytes,
9718                    used_bytes,
9719                    total_nodes,
9720                    used_nodes,
9721                    free_shared_pool_bytes,
9722                    fs_id,
9723                    block_size,
9724                    max_filename_size,
9725                    fs_type,
9726                    padding,
9727                    name,
9728
9729                } = out_;
9730            }
9731
9732            ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
9733
9734            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
9735
9736            ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
9737
9738            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
9739
9740            ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
9741
9742            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
9743
9744            ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
9745
9746            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
9747
9748            ::fidl_next::Encode::encode(
9749                self.free_shared_pool_bytes,
9750                encoder_,
9751                free_shared_pool_bytes,
9752                (),
9753            )?;
9754
9755            let mut _field =
9756                unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
9757
9758            ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
9759
9760            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
9761
9762            ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
9763
9764            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
9765
9766            ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
9767
9768            let mut _field =
9769                unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
9770
9771            ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
9772
9773            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
9774
9775            ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
9776
9777            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
9778
9779            ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
9780
9781            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
9782
9783            Ok(())
9784        }
9785    }
9786
9787    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for &'a FilesystemInfo
9788    where
9789        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9790    {
9791        #[inline]
9792        fn encode(
9793            self,
9794            encoder_: &mut ___E,
9795            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
9796            _: (),
9797        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9798            ::fidl_next::munge! {
9799                let crate::wire::FilesystemInfo {
9800                    total_bytes,
9801                    used_bytes,
9802                    total_nodes,
9803                    used_nodes,
9804                    free_shared_pool_bytes,
9805                    fs_id,
9806                    block_size,
9807                    max_filename_size,
9808                    fs_type,
9809                    padding,
9810                    name,
9811
9812                } = out_;
9813            }
9814
9815            ::fidl_next::Encode::encode(&self.total_bytes, encoder_, total_bytes, ())?;
9816
9817            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
9818
9819            ::fidl_next::Encode::encode(&self.used_bytes, encoder_, used_bytes, ())?;
9820
9821            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
9822
9823            ::fidl_next::Encode::encode(&self.total_nodes, encoder_, total_nodes, ())?;
9824
9825            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
9826
9827            ::fidl_next::Encode::encode(&self.used_nodes, encoder_, used_nodes, ())?;
9828
9829            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
9830
9831            ::fidl_next::Encode::encode(
9832                &self.free_shared_pool_bytes,
9833                encoder_,
9834                free_shared_pool_bytes,
9835                (),
9836            )?;
9837
9838            let mut _field =
9839                unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
9840
9841            ::fidl_next::Encode::encode(&self.fs_id, encoder_, fs_id, ())?;
9842
9843            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
9844
9845            ::fidl_next::Encode::encode(&self.block_size, encoder_, block_size, ())?;
9846
9847            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
9848
9849            ::fidl_next::Encode::encode(&self.max_filename_size, encoder_, max_filename_size, ())?;
9850
9851            let mut _field =
9852                unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
9853
9854            ::fidl_next::Encode::encode(&self.fs_type, encoder_, fs_type, ())?;
9855
9856            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
9857
9858            ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
9859
9860            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
9861
9862            ::fidl_next::Encode::encode(&self.name, encoder_, name, ())?;
9863
9864            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
9865
9866            Ok(())
9867        }
9868    }
9869
9870    unsafe impl<___E>
9871        ::fidl_next::EncodeOption<
9872            ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9873            ___E,
9874        > for FilesystemInfo
9875    where
9876        ___E: ::fidl_next::Encoder + ?Sized,
9877        FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
9878    {
9879        #[inline]
9880        fn encode_option(
9881            this: ::core::option::Option<Self>,
9882            encoder: &mut ___E,
9883            out: &mut ::core::mem::MaybeUninit<
9884                ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9885            >,
9886            _: (),
9887        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9888            if let Some(inner) = this {
9889                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9890                ::fidl_next::wire::Box::encode_present(out);
9891            } else {
9892                ::fidl_next::wire::Box::encode_absent(out);
9893            }
9894
9895            Ok(())
9896        }
9897    }
9898
9899    unsafe impl<'a, ___E>
9900        ::fidl_next::EncodeOption<
9901            ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9902            ___E,
9903        > for &'a FilesystemInfo
9904    where
9905        ___E: ::fidl_next::Encoder + ?Sized,
9906        &'a FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
9907    {
9908        #[inline]
9909        fn encode_option(
9910            this: ::core::option::Option<Self>,
9911            encoder: &mut ___E,
9912            out: &mut ::core::mem::MaybeUninit<
9913                ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9914            >,
9915            _: (),
9916        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9917            if let Some(inner) = this {
9918                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9919                ::fidl_next::wire::Box::encode_present(out);
9920            } else {
9921                ::fidl_next::wire::Box::encode_absent(out);
9922            }
9923
9924            Ok(())
9925        }
9926    }
9927
9928    impl ::fidl_next::FromWire<crate::wire::FilesystemInfo> for FilesystemInfo {
9929        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FilesystemInfo, Self> = unsafe {
9930            ::fidl_next::CopyOptimization::enable_if(
9931                true
9932                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9933                        .is_enabled()
9934                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9935                        .is_enabled()
9936                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9937                        .is_enabled()
9938                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9939                        .is_enabled()
9940                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9941                        .is_enabled()
9942                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9943                        .is_enabled()
9944                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
9945                        .is_enabled()
9946                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
9947                        .is_enabled()
9948                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
9949                        .is_enabled()
9950                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
9951                        .is_enabled()
9952                    && <[i8; 32] as ::fidl_next::FromWire<[i8; 32]>>::COPY_OPTIMIZATION
9953                        .is_enabled(),
9954            )
9955        };
9956
9957        #[inline]
9958        fn from_wire(wire: crate::wire::FilesystemInfo) -> Self {
9959            Self {
9960                total_bytes: ::fidl_next::FromWire::from_wire(wire.total_bytes),
9961
9962                used_bytes: ::fidl_next::FromWire::from_wire(wire.used_bytes),
9963
9964                total_nodes: ::fidl_next::FromWire::from_wire(wire.total_nodes),
9965
9966                used_nodes: ::fidl_next::FromWire::from_wire(wire.used_nodes),
9967
9968                free_shared_pool_bytes: ::fidl_next::FromWire::from_wire(
9969                    wire.free_shared_pool_bytes,
9970                ),
9971
9972                fs_id: ::fidl_next::FromWire::from_wire(wire.fs_id),
9973
9974                block_size: ::fidl_next::FromWire::from_wire(wire.block_size),
9975
9976                max_filename_size: ::fidl_next::FromWire::from_wire(wire.max_filename_size),
9977
9978                fs_type: ::fidl_next::FromWire::from_wire(wire.fs_type),
9979
9980                padding: ::fidl_next::FromWire::from_wire(wire.padding),
9981
9982                name: ::fidl_next::FromWire::from_wire(wire.name),
9983            }
9984        }
9985    }
9986
9987    impl ::fidl_next::FromWireRef<crate::wire::FilesystemInfo> for FilesystemInfo {
9988        #[inline]
9989        fn from_wire_ref(wire: &crate::wire::FilesystemInfo) -> Self {
9990            Self {
9991                total_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_bytes),
9992
9993                used_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_bytes),
9994
9995                total_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_nodes),
9996
9997                used_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_nodes),
9998
9999                free_shared_pool_bytes: ::fidl_next::FromWireRef::from_wire_ref(
10000                    &wire.free_shared_pool_bytes,
10001                ),
10002
10003                fs_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_id),
10004
10005                block_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.block_size),
10006
10007                max_filename_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_filename_size),
10008
10009                fs_type: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_type),
10010
10011                padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
10012
10013                name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
10014            }
10015        }
10016    }
10017
10018    pub type Service = ();
10019
10020    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10021    pub struct SymlinkObject {
10022        pub target: ::std::vec::Vec<u8>,
10023    }
10024
10025    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E> for SymlinkObject
10026    where
10027        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10028        ___E: ::fidl_next::Encoder,
10029    {
10030        #[inline]
10031        fn encode(
10032            self,
10033            encoder_: &mut ___E,
10034            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
10035            _: (),
10036        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10037            ::fidl_next::munge! {
10038                let crate::wire::SymlinkObject {
10039                    target,
10040
10041                } = out_;
10042            }
10043
10044            ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
10045
10046            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
10047            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
10048
10049            Ok(())
10050        }
10051    }
10052
10053    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
10054        for &'a SymlinkObject
10055    where
10056        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10057        ___E: ::fidl_next::Encoder,
10058    {
10059        #[inline]
10060        fn encode(
10061            self,
10062            encoder_: &mut ___E,
10063            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
10064            _: (),
10065        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10066            ::fidl_next::munge! {
10067                let crate::wire::SymlinkObject {
10068                    target,
10069
10070                } = out_;
10071            }
10072
10073            ::fidl_next::Encode::encode(&self.target, encoder_, target, (4095, ()))?;
10074
10075            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
10076            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
10077
10078            Ok(())
10079        }
10080    }
10081
10082    unsafe impl<___E>
10083        ::fidl_next::EncodeOption<
10084            ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10085            ___E,
10086        > for SymlinkObject
10087    where
10088        ___E: ::fidl_next::Encoder + ?Sized,
10089        SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
10090    {
10091        #[inline]
10092        fn encode_option(
10093            this: ::core::option::Option<Self>,
10094            encoder: &mut ___E,
10095            out: &mut ::core::mem::MaybeUninit<
10096                ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10097            >,
10098            _: (),
10099        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10100            if let Some(inner) = this {
10101                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10102                ::fidl_next::wire::Box::encode_present(out);
10103            } else {
10104                ::fidl_next::wire::Box::encode_absent(out);
10105            }
10106
10107            Ok(())
10108        }
10109    }
10110
10111    unsafe impl<'a, ___E>
10112        ::fidl_next::EncodeOption<
10113            ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10114            ___E,
10115        > for &'a SymlinkObject
10116    where
10117        ___E: ::fidl_next::Encoder + ?Sized,
10118        &'a SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
10119    {
10120        #[inline]
10121        fn encode_option(
10122            this: ::core::option::Option<Self>,
10123            encoder: &mut ___E,
10124            out: &mut ::core::mem::MaybeUninit<
10125                ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10126            >,
10127            _: (),
10128        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10129            if let Some(inner) = this {
10130                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10131                ::fidl_next::wire::Box::encode_present(out);
10132            } else {
10133                ::fidl_next::wire::Box::encode_absent(out);
10134            }
10135
10136            Ok(())
10137        }
10138    }
10139
10140    impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkObject<'de>> for SymlinkObject {
10141        #[inline]
10142        fn from_wire(wire: crate::wire::SymlinkObject<'de>) -> Self {
10143            Self { target: ::fidl_next::FromWire::from_wire(wire.target) }
10144        }
10145    }
10146
10147    impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkObject<'de>> for SymlinkObject {
10148        #[inline]
10149        fn from_wire_ref(wire: &crate::wire::SymlinkObject<'de>) -> Self {
10150            Self { target: ::fidl_next::FromWireRef::from_wire_ref(&wire.target) }
10151        }
10152    }
10153
10154    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10155    #[repr(u8)]
10156    pub enum WatchEvent {
10157        Deleted = 0,
10158        Added = 1,
10159        Removed = 2,
10160        Existing = 3,
10161        Idle = 4,
10162    }
10163    impl ::core::convert::TryFrom<u8> for WatchEvent {
10164        type Error = ::fidl_next::UnknownStrictEnumMemberError;
10165        fn try_from(
10166            value: u8,
10167        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
10168            match value {
10169                0 => Ok(Self::Deleted),
10170                1 => Ok(Self::Added),
10171                2 => Ok(Self::Removed),
10172                3 => Ok(Self::Existing),
10173                4 => Ok(Self::Idle),
10174
10175                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
10176            }
10177        }
10178    }
10179
10180    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for WatchEvent
10181    where
10182        ___E: ?Sized,
10183    {
10184        #[inline]
10185        fn encode(
10186            self,
10187            encoder: &mut ___E,
10188            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
10189            _: (),
10190        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10191            ::fidl_next::Encode::encode(&self, encoder, out, ())
10192        }
10193    }
10194
10195    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for &'a WatchEvent
10196    where
10197        ___E: ?Sized,
10198    {
10199        #[inline]
10200        fn encode(
10201            self,
10202            encoder: &mut ___E,
10203            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
10204            _: (),
10205        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10206            ::fidl_next::munge!(let crate::wire::WatchEvent { value } = out);
10207            let _ = value.write(u8::from(match *self {
10208                WatchEvent::Deleted => 0,
10209
10210                WatchEvent::Added => 1,
10211
10212                WatchEvent::Removed => 2,
10213
10214                WatchEvent::Existing => 3,
10215
10216                WatchEvent::Idle => 4,
10217            }));
10218
10219            Ok(())
10220        }
10221    }
10222
10223    impl ::core::convert::From<crate::wire::WatchEvent> for WatchEvent {
10224        fn from(wire: crate::wire::WatchEvent) -> Self {
10225            match u8::from(wire.value) {
10226                0 => Self::Deleted,
10227
10228                1 => Self::Added,
10229
10230                2 => Self::Removed,
10231
10232                3 => Self::Existing,
10233
10234                4 => Self::Idle,
10235
10236                _ => unsafe { ::core::hint::unreachable_unchecked() },
10237            }
10238        }
10239    }
10240
10241    impl ::fidl_next::FromWire<crate::wire::WatchEvent> for WatchEvent {
10242        #[inline]
10243        fn from_wire(wire: crate::wire::WatchEvent) -> Self {
10244            Self::from(wire)
10245        }
10246    }
10247
10248    impl ::fidl_next::FromWireRef<crate::wire::WatchEvent> for WatchEvent {
10249        #[inline]
10250        fn from_wire_ref(wire: &crate::wire::WatchEvent) -> Self {
10251            Self::from(*wire)
10252        }
10253    }
10254}
10255
10256pub mod wire {
10257
10258    /// The wire type corresponding to [`Operations`](crate::natural::Operations).
10259    #[derive(Clone, Copy, Debug)]
10260    #[repr(transparent)]
10261    pub struct Operations {
10262        pub(crate) value: ::fidl_next::wire::Uint64,
10263    }
10264
10265    impl ::fidl_next::Constrained for Operations {
10266        type Constraint = ();
10267
10268        fn validate(
10269            _: ::fidl_next::Slot<'_, Self>,
10270            _: Self::Constraint,
10271        ) -> Result<(), ::fidl_next::ValidationError> {
10272            Ok(())
10273        }
10274    }
10275
10276    unsafe impl ::fidl_next::Wire for Operations {
10277        type Narrowed<'de> = Self;
10278
10279        #[inline]
10280        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10281            // Wire bits have no padding
10282        }
10283    }
10284
10285    unsafe impl<___D> ::fidl_next::Decode<___D> for Operations
10286    where
10287        ___D: ?Sized,
10288    {
10289        fn decode(
10290            slot: ::fidl_next::Slot<'_, Self>,
10291            _: &mut ___D,
10292            _: (),
10293        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10294            ::fidl_next::munge!(let Self { value } = slot);
10295            let set = u64::from(*value);
10296            if set & !crate::natural::Operations::all().bits() != 0 {
10297                return Err(::fidl_next::DecodeError::InvalidBits {
10298                    expected: crate::natural::Operations::all().bits() as usize,
10299                    actual: set as usize,
10300                });
10301            }
10302
10303            Ok(())
10304        }
10305    }
10306
10307    impl ::core::convert::From<crate::natural::Operations> for Operations {
10308        fn from(natural: crate::natural::Operations) -> Self {
10309            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
10310        }
10311    }
10312
10313    impl ::fidl_next::IntoNatural for Operations {
10314        type Natural = crate::natural::Operations;
10315    }
10316
10317    /// The wire type corresponding to [`Abilities`](crate::natural::Abilities).
10318    pub type Abilities = crate::wire::Operations;
10319
10320    /// The wire type corresponding to [`SeekOrigin`].
10321    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10322    #[repr(transparent)]
10323    pub struct SeekOrigin {
10324        pub(crate) value: ::fidl_next::wire::Uint32,
10325    }
10326
10327    impl ::fidl_next::Constrained for SeekOrigin {
10328        type Constraint = ();
10329
10330        fn validate(
10331            _: ::fidl_next::Slot<'_, Self>,
10332            _: Self::Constraint,
10333        ) -> Result<(), ::fidl_next::ValidationError> {
10334            Ok(())
10335        }
10336    }
10337
10338    unsafe impl ::fidl_next::Wire for SeekOrigin {
10339        type Narrowed<'de> = Self;
10340
10341        #[inline]
10342        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10343            // Wire enums have no padding
10344        }
10345    }
10346
10347    impl SeekOrigin {
10348        pub const START: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(0) };
10349
10350        pub const CURRENT: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(1) };
10351
10352        pub const END: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(2) };
10353    }
10354
10355    unsafe impl<___D> ::fidl_next::Decode<___D> for SeekOrigin
10356    where
10357        ___D: ?Sized,
10358    {
10359        fn decode(
10360            slot: ::fidl_next::Slot<'_, Self>,
10361            _: &mut ___D,
10362            _: (),
10363        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10364            ::fidl_next::munge!(let Self { value } = slot);
10365
10366            match u32::from(*value) {
10367                0 | 1 | 2 => (),
10368                unknown => {
10369                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
10370                }
10371            }
10372
10373            Ok(())
10374        }
10375    }
10376
10377    impl ::core::convert::From<crate::natural::SeekOrigin> for SeekOrigin {
10378        fn from(natural: crate::natural::SeekOrigin) -> Self {
10379            match natural {
10380                crate::natural::SeekOrigin::Start => SeekOrigin::START,
10381
10382                crate::natural::SeekOrigin::Current => SeekOrigin::CURRENT,
10383
10384                crate::natural::SeekOrigin::End => SeekOrigin::END,
10385            }
10386        }
10387    }
10388
10389    impl ::fidl_next::IntoNatural for SeekOrigin {
10390        type Natural = crate::natural::SeekOrigin;
10391    }
10392
10393    /// The wire type corresponding to [`AdvisoryLockRange`].
10394    #[derive(Clone, Debug)]
10395    #[repr(C)]
10396    pub struct AdvisoryLockRange {
10397        pub origin: crate::wire::SeekOrigin,
10398
10399        pub offset: ::fidl_next::wire::Int64,
10400
10401        pub length: ::fidl_next::wire::Int64,
10402    }
10403
10404    static_assertions::const_assert_eq!(std::mem::size_of::<AdvisoryLockRange>(), 24);
10405    static_assertions::const_assert_eq!(std::mem::align_of::<AdvisoryLockRange>(), 8);
10406
10407    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, origin), 0);
10408
10409    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, offset), 8);
10410
10411    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, length), 16);
10412
10413    impl ::fidl_next::Constrained for AdvisoryLockRange {
10414        type Constraint = ();
10415
10416        fn validate(
10417            _: ::fidl_next::Slot<'_, Self>,
10418            _: Self::Constraint,
10419        ) -> Result<(), ::fidl_next::ValidationError> {
10420            Ok(())
10421        }
10422    }
10423
10424    unsafe impl ::fidl_next::Wire for AdvisoryLockRange {
10425        type Narrowed<'de> = AdvisoryLockRange;
10426
10427        #[inline]
10428        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10429            ::fidl_next::munge! {
10430                let Self {
10431                    origin,
10432                    offset,
10433                    length,
10434
10435                } = &mut *out_;
10436            }
10437
10438            ::fidl_next::Wire::zero_padding(origin);
10439
10440            ::fidl_next::Wire::zero_padding(offset);
10441
10442            ::fidl_next::Wire::zero_padding(length);
10443
10444            unsafe {
10445                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
10446            }
10447        }
10448    }
10449
10450    unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockRange
10451    where
10452        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10453    {
10454        fn decode(
10455            slot_: ::fidl_next::Slot<'_, Self>,
10456            decoder_: &mut ___D,
10457            _: (),
10458        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10459            if slot_.as_bytes()[4..8] != [0u8; 4] {
10460                return Err(::fidl_next::DecodeError::InvalidPadding);
10461            }
10462
10463            ::fidl_next::munge! {
10464                let Self {
10465                    mut origin,
10466                    mut offset,
10467                    mut length,
10468
10469                } = slot_;
10470            }
10471
10472            let _field = origin.as_mut();
10473
10474            ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
10475
10476            let _field = offset.as_mut();
10477
10478            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
10479
10480            let _field = length.as_mut();
10481
10482            ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
10483
10484            Ok(())
10485        }
10486    }
10487
10488    impl ::fidl_next::IntoNatural for AdvisoryLockRange {
10489        type Natural = crate::natural::AdvisoryLockRange;
10490    }
10491
10492    /// The wire type corresponding to [`AdvisoryLockType`].
10493    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10494    #[repr(transparent)]
10495    pub struct AdvisoryLockType {
10496        pub(crate) value: ::fidl_next::wire::Uint32,
10497    }
10498
10499    impl ::fidl_next::Constrained for AdvisoryLockType {
10500        type Constraint = ();
10501
10502        fn validate(
10503            _: ::fidl_next::Slot<'_, Self>,
10504            _: Self::Constraint,
10505        ) -> Result<(), ::fidl_next::ValidationError> {
10506            Ok(())
10507        }
10508    }
10509
10510    unsafe impl ::fidl_next::Wire for AdvisoryLockType {
10511        type Narrowed<'de> = Self;
10512
10513        #[inline]
10514        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10515            // Wire enums have no padding
10516        }
10517    }
10518
10519    impl AdvisoryLockType {
10520        pub const READ: AdvisoryLockType = AdvisoryLockType { value: ::fidl_next::wire::Uint32(1) };
10521
10522        pub const WRITE: AdvisoryLockType =
10523            AdvisoryLockType { value: ::fidl_next::wire::Uint32(2) };
10524
10525        pub const UNLOCK: AdvisoryLockType =
10526            AdvisoryLockType { value: ::fidl_next::wire::Uint32(3) };
10527    }
10528
10529    unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockType
10530    where
10531        ___D: ?Sized,
10532    {
10533        fn decode(
10534            slot: ::fidl_next::Slot<'_, Self>,
10535            _: &mut ___D,
10536            _: (),
10537        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10538            ::fidl_next::munge!(let Self { value } = slot);
10539
10540            match u32::from(*value) {
10541                1 | 2 | 3 => (),
10542                unknown => {
10543                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
10544                }
10545            }
10546
10547            Ok(())
10548        }
10549    }
10550
10551    impl ::core::convert::From<crate::natural::AdvisoryLockType> for AdvisoryLockType {
10552        fn from(natural: crate::natural::AdvisoryLockType) -> Self {
10553            match natural {
10554                crate::natural::AdvisoryLockType::Read => AdvisoryLockType::READ,
10555
10556                crate::natural::AdvisoryLockType::Write => AdvisoryLockType::WRITE,
10557
10558                crate::natural::AdvisoryLockType::Unlock => AdvisoryLockType::UNLOCK,
10559            }
10560        }
10561    }
10562
10563    impl ::fidl_next::IntoNatural for AdvisoryLockType {
10564        type Natural = crate::natural::AdvisoryLockType;
10565    }
10566
10567    /// The wire type corresponding to [`AdvisoryLockRequest`].
10568    #[repr(C)]
10569    pub struct AdvisoryLockRequest<'de> {
10570        pub(crate) table: ::fidl_next::wire::Table<'de>,
10571    }
10572
10573    impl<'de> Drop for AdvisoryLockRequest<'de> {
10574        fn drop(&mut self) {
10575            let _ = self.table.get(1).map(|envelope| unsafe {
10576                envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
10577            });
10578
10579            let _ = self.table.get(2).map(|envelope| unsafe {
10580                envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
10581            });
10582
10583            let _ = self.table.get(3).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
10584        }
10585    }
10586
10587    impl ::fidl_next::Constrained for AdvisoryLockRequest<'_> {
10588        type Constraint = ();
10589
10590        fn validate(
10591            _: ::fidl_next::Slot<'_, Self>,
10592            _: Self::Constraint,
10593        ) -> Result<(), ::fidl_next::ValidationError> {
10594            Ok(())
10595        }
10596    }
10597
10598    unsafe impl ::fidl_next::Wire for AdvisoryLockRequest<'static> {
10599        type Narrowed<'de> = AdvisoryLockRequest<'de>;
10600
10601        #[inline]
10602        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10603            ::fidl_next::munge!(let Self { table } = out);
10604            ::fidl_next::wire::Table::zero_padding(table);
10605        }
10606    }
10607
10608    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockRequest<'de>
10609    where
10610        ___D: ::fidl_next::Decoder<'de> + ?Sized,
10611    {
10612        fn decode(
10613            slot: ::fidl_next::Slot<'_, Self>,
10614            decoder: &mut ___D,
10615            _: (),
10616        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10617            ::fidl_next::munge!(let Self { table } = slot);
10618
10619            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
10620                match ordinal {
10621                    0 => unsafe { ::core::hint::unreachable_unchecked() },
10622
10623                    1 => {
10624                        ::fidl_next::wire::Envelope::decode_as::<
10625                            ___D,
10626                            crate::wire::AdvisoryLockType,
10627                        >(slot.as_mut(), decoder, ())?;
10628
10629                        Ok(())
10630                    }
10631
10632                    2 => {
10633                        ::fidl_next::wire::Envelope::decode_as::<
10634                            ___D,
10635                            crate::wire::AdvisoryLockRange,
10636                        >(slot.as_mut(), decoder, ())?;
10637
10638                        Ok(())
10639                    }
10640
10641                    3 => {
10642                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
10643                            slot.as_mut(),
10644                            decoder,
10645                            (),
10646                        )?;
10647
10648                        Ok(())
10649                    }
10650
10651                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
10652                }
10653            })
10654        }
10655    }
10656
10657    impl<'de> AdvisoryLockRequest<'de> {
10658        pub fn type_(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockType> {
10659            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
10660        }
10661
10662        pub fn take_type_(&mut self) -> ::core::option::Option<crate::wire::AdvisoryLockType> {
10663            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
10664        }
10665
10666        pub fn range(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockRange> {
10667            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
10668        }
10669
10670        pub fn take_range(&mut self) -> ::core::option::Option<crate::wire::AdvisoryLockRange> {
10671            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
10672        }
10673
10674        pub fn wait(&self) -> ::core::option::Option<&bool> {
10675            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
10676        }
10677
10678        pub fn take_wait(&mut self) -> ::core::option::Option<bool> {
10679            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
10680        }
10681    }
10682
10683    impl<'de> ::core::fmt::Debug for AdvisoryLockRequest<'de> {
10684        fn fmt(
10685            &self,
10686            f: &mut ::core::fmt::Formatter<'_>,
10687        ) -> ::core::result::Result<(), ::core::fmt::Error> {
10688            f.debug_struct("AdvisoryLockRequest")
10689                .field("type_", &self.type_())
10690                .field("range", &self.range())
10691                .field("wait", &self.wait())
10692                .finish()
10693        }
10694    }
10695
10696    impl<'de> ::fidl_next::IntoNatural for AdvisoryLockRequest<'de> {
10697        type Natural = crate::natural::AdvisoryLockRequest;
10698    }
10699
10700    /// The wire type corresponding to [`AdvisoryLockingAdvisoryLockRequest`].
10701    #[derive(Debug)]
10702    #[repr(C)]
10703    pub struct AdvisoryLockingAdvisoryLockRequest<'de> {
10704        pub request: crate::wire::AdvisoryLockRequest<'de>,
10705    }
10706
10707    static_assertions::const_assert_eq!(
10708        std::mem::size_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
10709        16
10710    );
10711    static_assertions::const_assert_eq!(
10712        std::mem::align_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
10713        8
10714    );
10715
10716    static_assertions::const_assert_eq!(
10717        std::mem::offset_of!(AdvisoryLockingAdvisoryLockRequest<'_>, request),
10718        0
10719    );
10720
10721    impl ::fidl_next::Constrained for AdvisoryLockingAdvisoryLockRequest<'_> {
10722        type Constraint = ();
10723
10724        fn validate(
10725            _: ::fidl_next::Slot<'_, Self>,
10726            _: Self::Constraint,
10727        ) -> Result<(), ::fidl_next::ValidationError> {
10728            Ok(())
10729        }
10730    }
10731
10732    unsafe impl ::fidl_next::Wire for AdvisoryLockingAdvisoryLockRequest<'static> {
10733        type Narrowed<'de> = AdvisoryLockingAdvisoryLockRequest<'de>;
10734
10735        #[inline]
10736        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10737            ::fidl_next::munge! {
10738                let Self {
10739                    request,
10740
10741                } = &mut *out_;
10742            }
10743
10744            ::fidl_next::Wire::zero_padding(request);
10745        }
10746    }
10747
10748    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockingAdvisoryLockRequest<'de>
10749    where
10750        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10751        ___D: ::fidl_next::Decoder<'de>,
10752    {
10753        fn decode(
10754            slot_: ::fidl_next::Slot<'_, Self>,
10755            decoder_: &mut ___D,
10756            _: (),
10757        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10758            ::fidl_next::munge! {
10759                let Self {
10760                    mut request,
10761
10762                } = slot_;
10763            }
10764
10765            let _field = request.as_mut();
10766
10767            ::fidl_next::Decode::decode(request.as_mut(), decoder_, ())?;
10768
10769            Ok(())
10770        }
10771    }
10772
10773    impl<'de> ::fidl_next::IntoNatural for AdvisoryLockingAdvisoryLockRequest<'de> {
10774        type Natural = crate::natural::AdvisoryLockingAdvisoryLockRequest;
10775    }
10776
10777    /// The wire type corresponding to [`AdvisoryLockingAdvisoryLockResponse`].
10778    pub type AdvisoryLockingAdvisoryLockResponse = ::fidl_next::wire::Unit;
10779
10780    /// The wire type corresponding to [`AllocateMode`](crate::natural::AllocateMode).
10781    #[derive(Clone, Copy, Debug)]
10782    #[repr(transparent)]
10783    pub struct AllocateMode {
10784        pub(crate) value: ::fidl_next::wire::Uint32,
10785    }
10786
10787    impl ::fidl_next::Constrained for AllocateMode {
10788        type Constraint = ();
10789
10790        fn validate(
10791            _: ::fidl_next::Slot<'_, Self>,
10792            _: Self::Constraint,
10793        ) -> Result<(), ::fidl_next::ValidationError> {
10794            Ok(())
10795        }
10796    }
10797
10798    unsafe impl ::fidl_next::Wire for AllocateMode {
10799        type Narrowed<'de> = Self;
10800
10801        #[inline]
10802        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10803            // Wire bits have no padding
10804        }
10805    }
10806
10807    unsafe impl<___D> ::fidl_next::Decode<___D> for AllocateMode
10808    where
10809        ___D: ?Sized,
10810    {
10811        fn decode(
10812            slot: ::fidl_next::Slot<'_, Self>,
10813            _: &mut ___D,
10814            _: (),
10815        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10816            Ok(())
10817        }
10818    }
10819
10820    impl ::core::convert::From<crate::natural::AllocateMode> for AllocateMode {
10821        fn from(natural: crate::natural::AllocateMode) -> Self {
10822            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
10823        }
10824    }
10825
10826    impl ::fidl_next::IntoNatural for AllocateMode {
10827        type Natural = crate::natural::AllocateMode;
10828    }
10829
10830    /// The wire type corresponding to [`Rights`](crate::natural::Rights).
10831    pub type Rights = crate::wire::Operations;
10832
10833    /// The wire type corresponding to [`Id`](crate::natural::Id).
10834    pub type Id = ::fidl_next::wire::Uint64;
10835
10836    /// The wire type corresponding to [`OpenFlags`](crate::natural::OpenFlags).
10837    #[derive(Clone, Copy, Debug)]
10838    #[repr(transparent)]
10839    pub struct OpenFlags {
10840        pub(crate) value: ::fidl_next::wire::Uint32,
10841    }
10842
10843    impl ::fidl_next::Constrained for OpenFlags {
10844        type Constraint = ();
10845
10846        fn validate(
10847            _: ::fidl_next::Slot<'_, Self>,
10848            _: Self::Constraint,
10849        ) -> Result<(), ::fidl_next::ValidationError> {
10850            Ok(())
10851        }
10852    }
10853
10854    unsafe impl ::fidl_next::Wire for OpenFlags {
10855        type Narrowed<'de> = Self;
10856
10857        #[inline]
10858        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10859            // Wire bits have no padding
10860        }
10861    }
10862
10863    unsafe impl<___D> ::fidl_next::Decode<___D> for OpenFlags
10864    where
10865        ___D: ?Sized,
10866    {
10867        fn decode(
10868            slot: ::fidl_next::Slot<'_, Self>,
10869            _: &mut ___D,
10870            _: (),
10871        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10872            ::fidl_next::munge!(let Self { value } = slot);
10873            let set = u32::from(*value);
10874            if set & !crate::natural::OpenFlags::all().bits() != 0 {
10875                return Err(::fidl_next::DecodeError::InvalidBits {
10876                    expected: crate::natural::OpenFlags::all().bits() as usize,
10877                    actual: set as usize,
10878                });
10879            }
10880
10881            Ok(())
10882        }
10883    }
10884
10885    impl ::core::convert::From<crate::natural::OpenFlags> for OpenFlags {
10886        fn from(natural: crate::natural::OpenFlags) -> Self {
10887            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
10888        }
10889    }
10890
10891    impl ::fidl_next::IntoNatural for OpenFlags {
10892        type Natural = crate::natural::OpenFlags;
10893    }
10894
10895    /// The wire type corresponding to [`NodeAttributes`].
10896    #[derive(Clone, Debug)]
10897    #[repr(C)]
10898    pub struct NodeAttributes {
10899        pub mode: ::fidl_next::wire::Uint32,
10900
10901        pub id: ::fidl_next::wire::Uint64,
10902
10903        pub content_size: ::fidl_next::wire::Uint64,
10904
10905        pub storage_size: ::fidl_next::wire::Uint64,
10906
10907        pub link_count: ::fidl_next::wire::Uint64,
10908
10909        pub creation_time: ::fidl_next::wire::Uint64,
10910
10911        pub modification_time: ::fidl_next::wire::Uint64,
10912    }
10913
10914    static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes>(), 56);
10915    static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes>(), 8);
10916
10917    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, mode), 0);
10918
10919    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, id), 8);
10920
10921    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, content_size), 16);
10922
10923    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, storage_size), 24);
10924
10925    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, link_count), 32);
10926
10927    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, creation_time), 40);
10928
10929    static_assertions::const_assert_eq!(
10930        std::mem::offset_of!(NodeAttributes, modification_time),
10931        48
10932    );
10933
10934    impl ::fidl_next::Constrained for NodeAttributes {
10935        type Constraint = ();
10936
10937        fn validate(
10938            _: ::fidl_next::Slot<'_, Self>,
10939            _: Self::Constraint,
10940        ) -> Result<(), ::fidl_next::ValidationError> {
10941            Ok(())
10942        }
10943    }
10944
10945    unsafe impl ::fidl_next::Wire for NodeAttributes {
10946        type Narrowed<'de> = NodeAttributes;
10947
10948        #[inline]
10949        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10950            ::fidl_next::munge! {
10951                let Self {
10952                    mode,
10953                    id,
10954                    content_size,
10955                    storage_size,
10956                    link_count,
10957                    creation_time,
10958                    modification_time,
10959
10960                } = &mut *out_;
10961            }
10962
10963            ::fidl_next::Wire::zero_padding(mode);
10964
10965            ::fidl_next::Wire::zero_padding(id);
10966
10967            ::fidl_next::Wire::zero_padding(content_size);
10968
10969            ::fidl_next::Wire::zero_padding(storage_size);
10970
10971            ::fidl_next::Wire::zero_padding(link_count);
10972
10973            ::fidl_next::Wire::zero_padding(creation_time);
10974
10975            ::fidl_next::Wire::zero_padding(modification_time);
10976
10977            unsafe {
10978                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
10979            }
10980        }
10981    }
10982
10983    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributes
10984    where
10985        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10986    {
10987        fn decode(
10988            slot_: ::fidl_next::Slot<'_, Self>,
10989            decoder_: &mut ___D,
10990            _: (),
10991        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10992            if slot_.as_bytes()[4..8] != [0u8; 4] {
10993                return Err(::fidl_next::DecodeError::InvalidPadding);
10994            }
10995
10996            ::fidl_next::munge! {
10997                let Self {
10998                    mut mode,
10999                    mut id,
11000                    mut content_size,
11001                    mut storage_size,
11002                    mut link_count,
11003                    mut creation_time,
11004                    mut modification_time,
11005
11006                } = slot_;
11007            }
11008
11009            let _field = mode.as_mut();
11010
11011            ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
11012
11013            let _field = id.as_mut();
11014
11015            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11016
11017            let _field = content_size.as_mut();
11018
11019            ::fidl_next::Decode::decode(content_size.as_mut(), decoder_, ())?;
11020
11021            let _field = storage_size.as_mut();
11022
11023            ::fidl_next::Decode::decode(storage_size.as_mut(), decoder_, ())?;
11024
11025            let _field = link_count.as_mut();
11026
11027            ::fidl_next::Decode::decode(link_count.as_mut(), decoder_, ())?;
11028
11029            let _field = creation_time.as_mut();
11030
11031            ::fidl_next::Decode::decode(creation_time.as_mut(), decoder_, ())?;
11032
11033            let _field = modification_time.as_mut();
11034
11035            ::fidl_next::Decode::decode(modification_time.as_mut(), decoder_, ())?;
11036
11037            Ok(())
11038        }
11039    }
11040
11041    impl ::fidl_next::IntoNatural for NodeAttributes {
11042        type Natural = crate::natural::NodeAttributes;
11043    }
11044
11045    /// The wire type corresponding to [`NodeAttributeFlags`](crate::natural::NodeAttributeFlags).
11046    #[derive(Clone, Copy, Debug)]
11047    #[repr(transparent)]
11048    pub struct NodeAttributeFlags {
11049        pub(crate) value: ::fidl_next::wire::Uint32,
11050    }
11051
11052    impl ::fidl_next::Constrained for NodeAttributeFlags {
11053        type Constraint = ();
11054
11055        fn validate(
11056            _: ::fidl_next::Slot<'_, Self>,
11057            _: Self::Constraint,
11058        ) -> Result<(), ::fidl_next::ValidationError> {
11059            Ok(())
11060        }
11061    }
11062
11063    unsafe impl ::fidl_next::Wire for NodeAttributeFlags {
11064        type Narrowed<'de> = Self;
11065
11066        #[inline]
11067        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11068            // Wire bits have no padding
11069        }
11070    }
11071
11072    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributeFlags
11073    where
11074        ___D: ?Sized,
11075    {
11076        fn decode(
11077            slot: ::fidl_next::Slot<'_, Self>,
11078            _: &mut ___D,
11079            _: (),
11080        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11081            ::fidl_next::munge!(let Self { value } = slot);
11082            let set = u32::from(*value);
11083            if set & !crate::natural::NodeAttributeFlags::all().bits() != 0 {
11084                return Err(::fidl_next::DecodeError::InvalidBits {
11085                    expected: crate::natural::NodeAttributeFlags::all().bits() as usize,
11086                    actual: set as usize,
11087                });
11088            }
11089
11090            Ok(())
11091        }
11092    }
11093
11094    impl ::core::convert::From<crate::natural::NodeAttributeFlags> for NodeAttributeFlags {
11095        fn from(natural: crate::natural::NodeAttributeFlags) -> Self {
11096            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11097        }
11098    }
11099
11100    impl ::fidl_next::IntoNatural for NodeAttributeFlags {
11101        type Natural = crate::natural::NodeAttributeFlags;
11102    }
11103
11104    /// The wire type corresponding to [`NodeQueryFilesystemResponse`].
11105    #[derive(Debug)]
11106    #[repr(C)]
11107    pub struct NodeQueryFilesystemResponse<'de> {
11108        pub s: ::fidl_next::wire::fuchsia::Status,
11109
11110        pub info: ::fidl_next::wire::Box<'de, crate::wire::FilesystemInfo>,
11111    }
11112
11113    static_assertions::const_assert_eq!(std::mem::size_of::<NodeQueryFilesystemResponse<'_>>(), 16);
11114    static_assertions::const_assert_eq!(std::mem::align_of::<NodeQueryFilesystemResponse<'_>>(), 8);
11115
11116    static_assertions::const_assert_eq!(
11117        std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, s),
11118        0
11119    );
11120
11121    static_assertions::const_assert_eq!(
11122        std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, info),
11123        8
11124    );
11125
11126    impl ::fidl_next::Constrained for NodeQueryFilesystemResponse<'_> {
11127        type Constraint = ();
11128
11129        fn validate(
11130            _: ::fidl_next::Slot<'_, Self>,
11131            _: Self::Constraint,
11132        ) -> Result<(), ::fidl_next::ValidationError> {
11133            Ok(())
11134        }
11135    }
11136
11137    unsafe impl ::fidl_next::Wire for NodeQueryFilesystemResponse<'static> {
11138        type Narrowed<'de> = NodeQueryFilesystemResponse<'de>;
11139
11140        #[inline]
11141        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11142            ::fidl_next::munge! {
11143                let Self {
11144                    s,
11145                    info,
11146
11147                } = &mut *out_;
11148            }
11149
11150            ::fidl_next::Wire::zero_padding(s);
11151
11152            ::fidl_next::Wire::zero_padding(info);
11153
11154            unsafe {
11155                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
11156            }
11157        }
11158    }
11159
11160    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeQueryFilesystemResponse<'de>
11161    where
11162        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11163        ___D: ::fidl_next::Decoder<'de>,
11164    {
11165        fn decode(
11166            slot_: ::fidl_next::Slot<'_, Self>,
11167            decoder_: &mut ___D,
11168            _: (),
11169        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11170            if slot_.as_bytes()[4..8] != [0u8; 4] {
11171                return Err(::fidl_next::DecodeError::InvalidPadding);
11172            }
11173
11174            ::fidl_next::munge! {
11175                let Self {
11176                    mut s,
11177                    mut info,
11178
11179                } = slot_;
11180            }
11181
11182            let _field = s.as_mut();
11183
11184            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11185
11186            let _field = info.as_mut();
11187
11188            ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
11189
11190            Ok(())
11191        }
11192    }
11193
11194    impl<'de> ::fidl_next::IntoNatural for NodeQueryFilesystemResponse<'de> {
11195        type Natural = crate::natural::NodeQueryFilesystemResponse;
11196    }
11197
11198    /// The wire type corresponding to [`NodeUpdateAttributesResponse`].
11199    pub type NodeUpdateAttributesResponse = ::fidl_next::wire::Unit;
11200
11201    /// The wire type corresponding to [`NodeSyncResponse`].
11202    pub type NodeSyncResponse = ::fidl_next::wire::Unit;
11203
11204    /// The wire type corresponding to [`ModeType`](crate::natural::ModeType).
11205    #[derive(Clone, Copy, Debug)]
11206    #[repr(transparent)]
11207    pub struct ModeType {
11208        pub(crate) value: ::fidl_next::wire::Uint32,
11209    }
11210
11211    impl ::fidl_next::Constrained for ModeType {
11212        type Constraint = ();
11213
11214        fn validate(
11215            _: ::fidl_next::Slot<'_, Self>,
11216            _: Self::Constraint,
11217        ) -> Result<(), ::fidl_next::ValidationError> {
11218            Ok(())
11219        }
11220    }
11221
11222    unsafe impl ::fidl_next::Wire for ModeType {
11223        type Narrowed<'de> = Self;
11224
11225        #[inline]
11226        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11227            // Wire bits have no padding
11228        }
11229    }
11230
11231    unsafe impl<___D> ::fidl_next::Decode<___D> for ModeType
11232    where
11233        ___D: ?Sized,
11234    {
11235        fn decode(
11236            slot: ::fidl_next::Slot<'_, Self>,
11237            _: &mut ___D,
11238            _: (),
11239        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11240            ::fidl_next::munge!(let Self { value } = slot);
11241            let set = u32::from(*value);
11242            if set & !crate::natural::ModeType::all().bits() != 0 {
11243                return Err(::fidl_next::DecodeError::InvalidBits {
11244                    expected: crate::natural::ModeType::all().bits() as usize,
11245                    actual: set as usize,
11246                });
11247            }
11248
11249            Ok(())
11250        }
11251    }
11252
11253    impl ::core::convert::From<crate::natural::ModeType> for ModeType {
11254        fn from(natural: crate::natural::ModeType) -> Self {
11255            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11256        }
11257    }
11258
11259    impl ::fidl_next::IntoNatural for ModeType {
11260        type Natural = crate::natural::ModeType;
11261    }
11262
11263    /// The wire type corresponding to [`Path`](crate::natural::Path).
11264    pub type Path<'de> = ::fidl_next::wire::String<'de>;
11265
11266    /// The wire type corresponding to [`DirectoryReadDirentsRequest`].
11267    #[derive(Clone, Debug)]
11268    #[repr(C)]
11269    pub struct DirectoryReadDirentsRequest {
11270        pub max_bytes: ::fidl_next::wire::Uint64,
11271    }
11272
11273    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryReadDirentsRequest>(), 8);
11274    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryReadDirentsRequest>(), 8);
11275
11276    static_assertions::const_assert_eq!(
11277        std::mem::offset_of!(DirectoryReadDirentsRequest, max_bytes),
11278        0
11279    );
11280
11281    impl ::fidl_next::Constrained for DirectoryReadDirentsRequest {
11282        type Constraint = ();
11283
11284        fn validate(
11285            _: ::fidl_next::Slot<'_, Self>,
11286            _: Self::Constraint,
11287        ) -> Result<(), ::fidl_next::ValidationError> {
11288            Ok(())
11289        }
11290    }
11291
11292    unsafe impl ::fidl_next::Wire for DirectoryReadDirentsRequest {
11293        type Narrowed<'de> = DirectoryReadDirentsRequest;
11294
11295        #[inline]
11296        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11297            ::fidl_next::munge! {
11298                let Self {
11299                    max_bytes,
11300
11301                } = &mut *out_;
11302            }
11303
11304            ::fidl_next::Wire::zero_padding(max_bytes);
11305        }
11306    }
11307
11308    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsRequest
11309    where
11310        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11311    {
11312        fn decode(
11313            slot_: ::fidl_next::Slot<'_, Self>,
11314            decoder_: &mut ___D,
11315            _: (),
11316        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11317            ::fidl_next::munge! {
11318                let Self {
11319                    mut max_bytes,
11320
11321                } = slot_;
11322            }
11323
11324            let _field = max_bytes.as_mut();
11325
11326            ::fidl_next::Decode::decode(max_bytes.as_mut(), decoder_, ())?;
11327
11328            Ok(())
11329        }
11330    }
11331
11332    impl ::fidl_next::IntoNatural for DirectoryReadDirentsRequest {
11333        type Natural = crate::natural::DirectoryReadDirentsRequest;
11334    }
11335
11336    /// The wire type corresponding to [`DirectoryReadDirentsResponse`].
11337    #[derive(Debug)]
11338    #[repr(C)]
11339    pub struct DirectoryReadDirentsResponse<'de> {
11340        pub s: ::fidl_next::wire::fuchsia::Status,
11341
11342        pub dirents: ::fidl_next::wire::Vector<'de, u8>,
11343    }
11344
11345    static_assertions::const_assert_eq!(
11346        std::mem::size_of::<DirectoryReadDirentsResponse<'_>>(),
11347        24
11348    );
11349    static_assertions::const_assert_eq!(
11350        std::mem::align_of::<DirectoryReadDirentsResponse<'_>>(),
11351        8
11352    );
11353
11354    static_assertions::const_assert_eq!(
11355        std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, s),
11356        0
11357    );
11358
11359    static_assertions::const_assert_eq!(
11360        std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, dirents),
11361        8
11362    );
11363
11364    impl ::fidl_next::Constrained for DirectoryReadDirentsResponse<'_> {
11365        type Constraint = ();
11366
11367        fn validate(
11368            _: ::fidl_next::Slot<'_, Self>,
11369            _: Self::Constraint,
11370        ) -> Result<(), ::fidl_next::ValidationError> {
11371            Ok(())
11372        }
11373    }
11374
11375    unsafe impl ::fidl_next::Wire for DirectoryReadDirentsResponse<'static> {
11376        type Narrowed<'de> = DirectoryReadDirentsResponse<'de>;
11377
11378        #[inline]
11379        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11380            ::fidl_next::munge! {
11381                let Self {
11382                    s,
11383                    dirents,
11384
11385                } = &mut *out_;
11386            }
11387
11388            ::fidl_next::Wire::zero_padding(s);
11389
11390            ::fidl_next::Wire::zero_padding(dirents);
11391
11392            unsafe {
11393                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
11394            }
11395        }
11396    }
11397
11398    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsResponse<'de>
11399    where
11400        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11401        ___D: ::fidl_next::Decoder<'de>,
11402    {
11403        fn decode(
11404            slot_: ::fidl_next::Slot<'_, Self>,
11405            decoder_: &mut ___D,
11406            _: (),
11407        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11408            if slot_.as_bytes()[4..8] != [0u8; 4] {
11409                return Err(::fidl_next::DecodeError::InvalidPadding);
11410            }
11411
11412            ::fidl_next::munge! {
11413                let Self {
11414                    mut s,
11415                    mut dirents,
11416
11417                } = slot_;
11418            }
11419
11420            let _field = s.as_mut();
11421
11422            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11423
11424            let _field = dirents.as_mut();
11425            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
11426            ::fidl_next::Decode::decode(dirents.as_mut(), decoder_, (8192, ()))?;
11427
11428            let dirents = unsafe { dirents.deref_unchecked() };
11429
11430            if dirents.len() > 8192 {
11431                return Err(::fidl_next::DecodeError::VectorTooLong {
11432                    size: dirents.len() as u64,
11433                    limit: 8192,
11434                });
11435            }
11436
11437            Ok(())
11438        }
11439    }
11440
11441    impl<'de> ::fidl_next::IntoNatural for DirectoryReadDirentsResponse<'de> {
11442        type Natural = crate::natural::DirectoryReadDirentsResponse;
11443    }
11444
11445    /// The wire type corresponding to [`DirectoryRewindResponse`].
11446    #[derive(Clone, Debug)]
11447    #[repr(C)]
11448    pub struct DirectoryRewindResponse {
11449        pub s: ::fidl_next::wire::fuchsia::Status,
11450    }
11451
11452    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRewindResponse>(), 4);
11453    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRewindResponse>(), 4);
11454
11455    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRewindResponse, s), 0);
11456
11457    impl ::fidl_next::Constrained for DirectoryRewindResponse {
11458        type Constraint = ();
11459
11460        fn validate(
11461            _: ::fidl_next::Slot<'_, Self>,
11462            _: Self::Constraint,
11463        ) -> Result<(), ::fidl_next::ValidationError> {
11464            Ok(())
11465        }
11466    }
11467
11468    unsafe impl ::fidl_next::Wire for DirectoryRewindResponse {
11469        type Narrowed<'de> = DirectoryRewindResponse;
11470
11471        #[inline]
11472        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11473            ::fidl_next::munge! {
11474                let Self {
11475                    s,
11476
11477                } = &mut *out_;
11478            }
11479
11480            ::fidl_next::Wire::zero_padding(s);
11481        }
11482    }
11483
11484    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRewindResponse
11485    where
11486        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11487    {
11488        fn decode(
11489            slot_: ::fidl_next::Slot<'_, Self>,
11490            decoder_: &mut ___D,
11491            _: (),
11492        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11493            ::fidl_next::munge! {
11494                let Self {
11495                    mut s,
11496
11497                } = slot_;
11498            }
11499
11500            let _field = s.as_mut();
11501
11502            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11503
11504            Ok(())
11505        }
11506    }
11507
11508    impl ::fidl_next::IntoNatural for DirectoryRewindResponse {
11509        type Natural = crate::natural::DirectoryRewindResponse;
11510    }
11511
11512    /// The wire type corresponding to [`Name`](crate::natural::Name).
11513    pub type Name<'de> = ::fidl_next::wire::String<'de>;
11514
11515    /// The wire type corresponding to [`DirectoryLinkResponse`].
11516    #[derive(Clone, Debug)]
11517    #[repr(C)]
11518    pub struct DirectoryLinkResponse {
11519        pub s: ::fidl_next::wire::fuchsia::Status,
11520    }
11521
11522    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkResponse>(), 4);
11523    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkResponse>(), 4);
11524
11525    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkResponse, s), 0);
11526
11527    impl ::fidl_next::Constrained for DirectoryLinkResponse {
11528        type Constraint = ();
11529
11530        fn validate(
11531            _: ::fidl_next::Slot<'_, Self>,
11532            _: Self::Constraint,
11533        ) -> Result<(), ::fidl_next::ValidationError> {
11534            Ok(())
11535        }
11536    }
11537
11538    unsafe impl ::fidl_next::Wire for DirectoryLinkResponse {
11539        type Narrowed<'de> = DirectoryLinkResponse;
11540
11541        #[inline]
11542        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11543            ::fidl_next::munge! {
11544                let Self {
11545                    s,
11546
11547                } = &mut *out_;
11548            }
11549
11550            ::fidl_next::Wire::zero_padding(s);
11551        }
11552    }
11553
11554    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryLinkResponse
11555    where
11556        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11557    {
11558        fn decode(
11559            slot_: ::fidl_next::Slot<'_, Self>,
11560            decoder_: &mut ___D,
11561            _: (),
11562        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11563            ::fidl_next::munge! {
11564                let Self {
11565                    mut s,
11566
11567                } = slot_;
11568            }
11569
11570            let _field = s.as_mut();
11571
11572            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11573
11574            Ok(())
11575        }
11576    }
11577
11578    impl ::fidl_next::IntoNatural for DirectoryLinkResponse {
11579        type Natural = crate::natural::DirectoryLinkResponse;
11580    }
11581
11582    /// The wire type corresponding to [`UnlinkFlags`](crate::natural::UnlinkFlags).
11583    #[derive(Clone, Copy, Debug)]
11584    #[repr(transparent)]
11585    pub struct UnlinkFlags {
11586        pub(crate) value: ::fidl_next::wire::Uint64,
11587    }
11588
11589    impl ::fidl_next::Constrained for UnlinkFlags {
11590        type Constraint = ();
11591
11592        fn validate(
11593            _: ::fidl_next::Slot<'_, Self>,
11594            _: Self::Constraint,
11595        ) -> Result<(), ::fidl_next::ValidationError> {
11596            Ok(())
11597        }
11598    }
11599
11600    unsafe impl ::fidl_next::Wire for UnlinkFlags {
11601        type Narrowed<'de> = Self;
11602
11603        #[inline]
11604        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11605            // Wire bits have no padding
11606        }
11607    }
11608
11609    unsafe impl<___D> ::fidl_next::Decode<___D> for UnlinkFlags
11610    where
11611        ___D: ?Sized,
11612    {
11613        fn decode(
11614            slot: ::fidl_next::Slot<'_, Self>,
11615            _: &mut ___D,
11616            _: (),
11617        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11618            Ok(())
11619        }
11620    }
11621
11622    impl ::core::convert::From<crate::natural::UnlinkFlags> for UnlinkFlags {
11623        fn from(natural: crate::natural::UnlinkFlags) -> Self {
11624            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
11625        }
11626    }
11627
11628    impl ::fidl_next::IntoNatural for UnlinkFlags {
11629        type Natural = crate::natural::UnlinkFlags;
11630    }
11631
11632    /// The wire type corresponding to [`UnlinkOptions`].
11633    #[repr(C)]
11634    pub struct UnlinkOptions<'de> {
11635        pub(crate) table: ::fidl_next::wire::Table<'de>,
11636    }
11637
11638    impl<'de> Drop for UnlinkOptions<'de> {
11639        fn drop(&mut self) {
11640            let _ = self
11641                .table
11642                .get(1)
11643                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::UnlinkFlags>() });
11644        }
11645    }
11646
11647    impl ::fidl_next::Constrained for UnlinkOptions<'_> {
11648        type Constraint = ();
11649
11650        fn validate(
11651            _: ::fidl_next::Slot<'_, Self>,
11652            _: Self::Constraint,
11653        ) -> Result<(), ::fidl_next::ValidationError> {
11654            Ok(())
11655        }
11656    }
11657
11658    unsafe impl ::fidl_next::Wire for UnlinkOptions<'static> {
11659        type Narrowed<'de> = UnlinkOptions<'de>;
11660
11661        #[inline]
11662        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
11663            ::fidl_next::munge!(let Self { table } = out);
11664            ::fidl_next::wire::Table::zero_padding(table);
11665        }
11666    }
11667
11668    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnlinkOptions<'de>
11669    where
11670        ___D: ::fidl_next::Decoder<'de> + ?Sized,
11671    {
11672        fn decode(
11673            slot: ::fidl_next::Slot<'_, Self>,
11674            decoder: &mut ___D,
11675            _: (),
11676        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11677            ::fidl_next::munge!(let Self { table } = slot);
11678
11679            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
11680                match ordinal {
11681                    0 => unsafe { ::core::hint::unreachable_unchecked() },
11682
11683                    1 => {
11684                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::UnlinkFlags>(
11685                            slot.as_mut(),
11686                            decoder,
11687                            (),
11688                        )?;
11689
11690                        Ok(())
11691                    }
11692
11693                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
11694                }
11695            })
11696        }
11697    }
11698
11699    impl<'de> UnlinkOptions<'de> {
11700        pub fn flags(&self) -> ::core::option::Option<&crate::wire::UnlinkFlags> {
11701            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
11702        }
11703
11704        pub fn take_flags(&mut self) -> ::core::option::Option<crate::wire::UnlinkFlags> {
11705            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
11706        }
11707    }
11708
11709    impl<'de> ::core::fmt::Debug for UnlinkOptions<'de> {
11710        fn fmt(
11711            &self,
11712            f: &mut ::core::fmt::Formatter<'_>,
11713        ) -> ::core::result::Result<(), ::core::fmt::Error> {
11714            f.debug_struct("UnlinkOptions").field("flags", &self.flags()).finish()
11715        }
11716    }
11717
11718    impl<'de> ::fidl_next::IntoNatural for UnlinkOptions<'de> {
11719        type Natural = crate::natural::UnlinkOptions;
11720    }
11721
11722    /// The wire type corresponding to [`DirectoryUnlinkRequest`].
11723    #[derive(Debug)]
11724    #[repr(C)]
11725    pub struct DirectoryUnlinkRequest<'de> {
11726        pub name: ::fidl_next::wire::String<'de>,
11727
11728        pub options: crate::wire::UnlinkOptions<'de>,
11729    }
11730
11731    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryUnlinkRequest<'_>>(), 32);
11732    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryUnlinkRequest<'_>>(), 8);
11733
11734    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryUnlinkRequest<'_>, name), 0);
11735
11736    static_assertions::const_assert_eq!(
11737        std::mem::offset_of!(DirectoryUnlinkRequest<'_>, options),
11738        16
11739    );
11740
11741    impl ::fidl_next::Constrained for DirectoryUnlinkRequest<'_> {
11742        type Constraint = ();
11743
11744        fn validate(
11745            _: ::fidl_next::Slot<'_, Self>,
11746            _: Self::Constraint,
11747        ) -> Result<(), ::fidl_next::ValidationError> {
11748            Ok(())
11749        }
11750    }
11751
11752    unsafe impl ::fidl_next::Wire for DirectoryUnlinkRequest<'static> {
11753        type Narrowed<'de> = DirectoryUnlinkRequest<'de>;
11754
11755        #[inline]
11756        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11757            ::fidl_next::munge! {
11758                let Self {
11759                    name,
11760                    options,
11761
11762                } = &mut *out_;
11763            }
11764
11765            ::fidl_next::Wire::zero_padding(name);
11766
11767            ::fidl_next::Wire::zero_padding(options);
11768        }
11769    }
11770
11771    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryUnlinkRequest<'de>
11772    where
11773        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11774        ___D: ::fidl_next::Decoder<'de>,
11775    {
11776        fn decode(
11777            slot_: ::fidl_next::Slot<'_, Self>,
11778            decoder_: &mut ___D,
11779            _: (),
11780        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11781            ::fidl_next::munge! {
11782                let Self {
11783                    mut name,
11784                    mut options,
11785
11786                } = slot_;
11787            }
11788
11789            let _field = name.as_mut();
11790            ::fidl_next::Constrained::validate(_field, 255)?;
11791            ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
11792
11793            let name = unsafe { name.deref_unchecked() };
11794
11795            if name.len() > 255 {
11796                return Err(::fidl_next::DecodeError::VectorTooLong {
11797                    size: name.len() as u64,
11798                    limit: 255,
11799                });
11800            }
11801
11802            let _field = options.as_mut();
11803
11804            ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
11805
11806            Ok(())
11807        }
11808    }
11809
11810    impl<'de> ::fidl_next::IntoNatural for DirectoryUnlinkRequest<'de> {
11811        type Natural = crate::natural::DirectoryUnlinkRequest;
11812    }
11813
11814    /// The wire type corresponding to [`DirectoryUnlinkResponse`].
11815    pub type DirectoryUnlinkResponse = ::fidl_next::wire::Unit;
11816
11817    /// The wire type corresponding to [`DirectoryRenameResponse`].
11818    pub type DirectoryRenameResponse = ::fidl_next::wire::Unit;
11819
11820    /// The wire type corresponding to [`WatchMask`](crate::natural::WatchMask).
11821    #[derive(Clone, Copy, Debug)]
11822    #[repr(transparent)]
11823    pub struct WatchMask {
11824        pub(crate) value: ::fidl_next::wire::Uint32,
11825    }
11826
11827    impl ::fidl_next::Constrained for WatchMask {
11828        type Constraint = ();
11829
11830        fn validate(
11831            _: ::fidl_next::Slot<'_, Self>,
11832            _: Self::Constraint,
11833        ) -> Result<(), ::fidl_next::ValidationError> {
11834            Ok(())
11835        }
11836    }
11837
11838    unsafe impl ::fidl_next::Wire for WatchMask {
11839        type Narrowed<'de> = Self;
11840
11841        #[inline]
11842        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11843            // Wire bits have no padding
11844        }
11845    }
11846
11847    unsafe impl<___D> ::fidl_next::Decode<___D> for WatchMask
11848    where
11849        ___D: ?Sized,
11850    {
11851        fn decode(
11852            slot: ::fidl_next::Slot<'_, Self>,
11853            _: &mut ___D,
11854            _: (),
11855        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11856            ::fidl_next::munge!(let Self { value } = slot);
11857            let set = u32::from(*value);
11858            if set & !crate::natural::WatchMask::all().bits() != 0 {
11859                return Err(::fidl_next::DecodeError::InvalidBits {
11860                    expected: crate::natural::WatchMask::all().bits() as usize,
11861                    actual: set as usize,
11862                });
11863            }
11864
11865            Ok(())
11866        }
11867    }
11868
11869    impl ::core::convert::From<crate::natural::WatchMask> for WatchMask {
11870        fn from(natural: crate::natural::WatchMask) -> Self {
11871            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11872        }
11873    }
11874
11875    impl ::fidl_next::IntoNatural for WatchMask {
11876        type Natural = crate::natural::WatchMask;
11877    }
11878
11879    /// The wire type corresponding to [`DirectoryWatchResponse`].
11880    #[derive(Clone, Debug)]
11881    #[repr(C)]
11882    pub struct DirectoryWatchResponse {
11883        pub s: ::fidl_next::wire::fuchsia::Status,
11884    }
11885
11886    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchResponse>(), 4);
11887    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchResponse>(), 4);
11888
11889    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchResponse, s), 0);
11890
11891    impl ::fidl_next::Constrained for DirectoryWatchResponse {
11892        type Constraint = ();
11893
11894        fn validate(
11895            _: ::fidl_next::Slot<'_, Self>,
11896            _: Self::Constraint,
11897        ) -> Result<(), ::fidl_next::ValidationError> {
11898            Ok(())
11899        }
11900    }
11901
11902    unsafe impl ::fidl_next::Wire for DirectoryWatchResponse {
11903        type Narrowed<'de> = DirectoryWatchResponse;
11904
11905        #[inline]
11906        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11907            ::fidl_next::munge! {
11908                let Self {
11909                    s,
11910
11911                } = &mut *out_;
11912            }
11913
11914            ::fidl_next::Wire::zero_padding(s);
11915        }
11916    }
11917
11918    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchResponse
11919    where
11920        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11921    {
11922        fn decode(
11923            slot_: ::fidl_next::Slot<'_, Self>,
11924            decoder_: &mut ___D,
11925            _: (),
11926        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11927            ::fidl_next::munge! {
11928                let Self {
11929                    mut s,
11930
11931                } = slot_;
11932            }
11933
11934            let _field = s.as_mut();
11935
11936            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11937
11938            Ok(())
11939        }
11940    }
11941
11942    impl ::fidl_next::IntoNatural for DirectoryWatchResponse {
11943        type Natural = crate::natural::DirectoryWatchResponse;
11944    }
11945
11946    /// The wire type corresponding to [`SymlinkTarget`](crate::natural::SymlinkTarget).
11947    pub type SymlinkTarget<'de> = ::fidl_next::wire::Vector<'de, u8>;
11948
11949    /// The wire type corresponding to [`ExtendedAttributeName`](crate::natural::ExtendedAttributeName).
11950    pub type ExtendedAttributeName<'de> = ::fidl_next::wire::Vector<'de, u8>;
11951
11952    /// The wire type corresponding to [`NodeGetExtendedAttributeRequest`].
11953    #[derive(Debug)]
11954    #[repr(C)]
11955    pub struct NodeGetExtendedAttributeRequest<'de> {
11956        pub name: ::fidl_next::wire::Vector<'de, u8>,
11957    }
11958
11959    static_assertions::const_assert_eq!(
11960        std::mem::size_of::<NodeGetExtendedAttributeRequest<'_>>(),
11961        16
11962    );
11963    static_assertions::const_assert_eq!(
11964        std::mem::align_of::<NodeGetExtendedAttributeRequest<'_>>(),
11965        8
11966    );
11967
11968    static_assertions::const_assert_eq!(
11969        std::mem::offset_of!(NodeGetExtendedAttributeRequest<'_>, name),
11970        0
11971    );
11972
11973    impl ::fidl_next::Constrained for NodeGetExtendedAttributeRequest<'_> {
11974        type Constraint = ();
11975
11976        fn validate(
11977            _: ::fidl_next::Slot<'_, Self>,
11978            _: Self::Constraint,
11979        ) -> Result<(), ::fidl_next::ValidationError> {
11980            Ok(())
11981        }
11982    }
11983
11984    unsafe impl ::fidl_next::Wire for NodeGetExtendedAttributeRequest<'static> {
11985        type Narrowed<'de> = NodeGetExtendedAttributeRequest<'de>;
11986
11987        #[inline]
11988        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11989            ::fidl_next::munge! {
11990                let Self {
11991                    name,
11992
11993                } = &mut *out_;
11994            }
11995
11996            ::fidl_next::Wire::zero_padding(name);
11997        }
11998    }
11999
12000    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeGetExtendedAttributeRequest<'de>
12001    where
12002        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12003        ___D: ::fidl_next::Decoder<'de>,
12004    {
12005        fn decode(
12006            slot_: ::fidl_next::Slot<'_, Self>,
12007            decoder_: &mut ___D,
12008            _: (),
12009        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12010            ::fidl_next::munge! {
12011                let Self {
12012                    mut name,
12013
12014                } = slot_;
12015            }
12016
12017            let _field = name.as_mut();
12018            ::fidl_next::Constrained::validate(_field, (255, ()))?;
12019            ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
12020
12021            let name = unsafe { name.deref_unchecked() };
12022
12023            if name.len() > 255 {
12024                return Err(::fidl_next::DecodeError::VectorTooLong {
12025                    size: name.len() as u64,
12026                    limit: 255,
12027                });
12028            }
12029
12030            Ok(())
12031        }
12032    }
12033
12034    impl<'de> ::fidl_next::IntoNatural for NodeGetExtendedAttributeRequest<'de> {
12035        type Natural = crate::natural::NodeGetExtendedAttributeRequest;
12036    }
12037
12038    /// The wire type corresponding to [`SetExtendedAttributeMode`].
12039    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12040    #[repr(transparent)]
12041    pub struct SetExtendedAttributeMode {
12042        pub(crate) value: ::fidl_next::wire::Uint32,
12043    }
12044
12045    impl ::fidl_next::Constrained for SetExtendedAttributeMode {
12046        type Constraint = ();
12047
12048        fn validate(
12049            _: ::fidl_next::Slot<'_, Self>,
12050            _: Self::Constraint,
12051        ) -> Result<(), ::fidl_next::ValidationError> {
12052            Ok(())
12053        }
12054    }
12055
12056    unsafe impl ::fidl_next::Wire for SetExtendedAttributeMode {
12057        type Narrowed<'de> = Self;
12058
12059        #[inline]
12060        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12061            // Wire enums have no padding
12062        }
12063    }
12064
12065    impl SetExtendedAttributeMode {
12066        pub const SET: SetExtendedAttributeMode =
12067            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(1) };
12068
12069        pub const CREATE: SetExtendedAttributeMode =
12070            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(2) };
12071
12072        pub const REPLACE: SetExtendedAttributeMode =
12073            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(3) };
12074    }
12075
12076    unsafe impl<___D> ::fidl_next::Decode<___D> for SetExtendedAttributeMode
12077    where
12078        ___D: ?Sized,
12079    {
12080        fn decode(
12081            slot: ::fidl_next::Slot<'_, Self>,
12082            _: &mut ___D,
12083            _: (),
12084        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12085            ::fidl_next::munge!(let Self { value } = slot);
12086
12087            match u32::from(*value) {
12088                1 | 2 | 3 => (),
12089                unknown => {
12090                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
12091                }
12092            }
12093
12094            Ok(())
12095        }
12096    }
12097
12098    impl ::core::convert::From<crate::natural::SetExtendedAttributeMode> for SetExtendedAttributeMode {
12099        fn from(natural: crate::natural::SetExtendedAttributeMode) -> Self {
12100            match natural {
12101                crate::natural::SetExtendedAttributeMode::Set => SetExtendedAttributeMode::SET,
12102
12103                crate::natural::SetExtendedAttributeMode::Create => {
12104                    SetExtendedAttributeMode::CREATE
12105                }
12106
12107                crate::natural::SetExtendedAttributeMode::Replace => {
12108                    SetExtendedAttributeMode::REPLACE
12109                }
12110            }
12111        }
12112    }
12113
12114    impl ::fidl_next::IntoNatural for SetExtendedAttributeMode {
12115        type Natural = crate::natural::SetExtendedAttributeMode;
12116    }
12117
12118    /// The wire type corresponding to [`NodeSetExtendedAttributeResponse`].
12119    pub type NodeSetExtendedAttributeResponse = ::fidl_next::wire::Unit;
12120
12121    /// The wire type corresponding to [`NodeRemoveExtendedAttributeRequest`].
12122    #[derive(Debug)]
12123    #[repr(C)]
12124    pub struct NodeRemoveExtendedAttributeRequest<'de> {
12125        pub name: ::fidl_next::wire::Vector<'de, u8>,
12126    }
12127
12128    static_assertions::const_assert_eq!(
12129        std::mem::size_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
12130        16
12131    );
12132    static_assertions::const_assert_eq!(
12133        std::mem::align_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
12134        8
12135    );
12136
12137    static_assertions::const_assert_eq!(
12138        std::mem::offset_of!(NodeRemoveExtendedAttributeRequest<'_>, name),
12139        0
12140    );
12141
12142    impl ::fidl_next::Constrained for NodeRemoveExtendedAttributeRequest<'_> {
12143        type Constraint = ();
12144
12145        fn validate(
12146            _: ::fidl_next::Slot<'_, Self>,
12147            _: Self::Constraint,
12148        ) -> Result<(), ::fidl_next::ValidationError> {
12149            Ok(())
12150        }
12151    }
12152
12153    unsafe impl ::fidl_next::Wire for NodeRemoveExtendedAttributeRequest<'static> {
12154        type Narrowed<'de> = NodeRemoveExtendedAttributeRequest<'de>;
12155
12156        #[inline]
12157        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12158            ::fidl_next::munge! {
12159                let Self {
12160                    name,
12161
12162                } = &mut *out_;
12163            }
12164
12165            ::fidl_next::Wire::zero_padding(name);
12166        }
12167    }
12168
12169    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeRemoveExtendedAttributeRequest<'de>
12170    where
12171        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12172        ___D: ::fidl_next::Decoder<'de>,
12173    {
12174        fn decode(
12175            slot_: ::fidl_next::Slot<'_, Self>,
12176            decoder_: &mut ___D,
12177            _: (),
12178        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12179            ::fidl_next::munge! {
12180                let Self {
12181                    mut name,
12182
12183                } = slot_;
12184            }
12185
12186            let _field = name.as_mut();
12187            ::fidl_next::Constrained::validate(_field, (255, ()))?;
12188            ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
12189
12190            let name = unsafe { name.deref_unchecked() };
12191
12192            if name.len() > 255 {
12193                return Err(::fidl_next::DecodeError::VectorTooLong {
12194                    size: name.len() as u64,
12195                    limit: 255,
12196                });
12197            }
12198
12199            Ok(())
12200        }
12201    }
12202
12203    impl<'de> ::fidl_next::IntoNatural for NodeRemoveExtendedAttributeRequest<'de> {
12204        type Natural = crate::natural::NodeRemoveExtendedAttributeRequest;
12205    }
12206
12207    /// The wire type corresponding to [`NodeRemoveExtendedAttributeResponse`].
12208    pub type NodeRemoveExtendedAttributeResponse = ::fidl_next::wire::Unit;
12209
12210    /// The wire type corresponding to [`DirectoryCreateSymlinkResponse`].
12211    pub type DirectoryCreateSymlinkResponse = ::fidl_next::wire::Unit;
12212
12213    /// The wire type corresponding to [`NodeSetFlagsResponse`].
12214    pub type NodeSetFlagsResponse = ::fidl_next::wire::Unit;
12215
12216    /// The wire type corresponding to [`NodeDeprecatedGetAttrResponse`].
12217    #[derive(Clone, Debug)]
12218    #[repr(C)]
12219    pub struct NodeDeprecatedGetAttrResponse {
12220        pub s: ::fidl_next::wire::fuchsia::Status,
12221
12222        pub attributes: crate::wire::NodeAttributes,
12223    }
12224
12225    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetAttrResponse>(), 64);
12226    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetAttrResponse>(), 8);
12227
12228    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetAttrResponse, s), 0);
12229
12230    static_assertions::const_assert_eq!(
12231        std::mem::offset_of!(NodeDeprecatedGetAttrResponse, attributes),
12232        8
12233    );
12234
12235    impl ::fidl_next::Constrained for NodeDeprecatedGetAttrResponse {
12236        type Constraint = ();
12237
12238        fn validate(
12239            _: ::fidl_next::Slot<'_, Self>,
12240            _: Self::Constraint,
12241        ) -> Result<(), ::fidl_next::ValidationError> {
12242            Ok(())
12243        }
12244    }
12245
12246    unsafe impl ::fidl_next::Wire for NodeDeprecatedGetAttrResponse {
12247        type Narrowed<'de> = NodeDeprecatedGetAttrResponse;
12248
12249        #[inline]
12250        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12251            ::fidl_next::munge! {
12252                let Self {
12253                    s,
12254                    attributes,
12255
12256                } = &mut *out_;
12257            }
12258
12259            ::fidl_next::Wire::zero_padding(s);
12260
12261            ::fidl_next::Wire::zero_padding(attributes);
12262
12263            unsafe {
12264                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
12265            }
12266        }
12267    }
12268
12269    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetAttrResponse
12270    where
12271        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12272    {
12273        fn decode(
12274            slot_: ::fidl_next::Slot<'_, Self>,
12275            decoder_: &mut ___D,
12276            _: (),
12277        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12278            if slot_.as_bytes()[4..8] != [0u8; 4] {
12279                return Err(::fidl_next::DecodeError::InvalidPadding);
12280            }
12281
12282            ::fidl_next::munge! {
12283                let Self {
12284                    mut s,
12285                    mut attributes,
12286
12287                } = slot_;
12288            }
12289
12290            let _field = s.as_mut();
12291
12292            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12293
12294            let _field = attributes.as_mut();
12295
12296            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
12297
12298            Ok(())
12299        }
12300    }
12301
12302    impl ::fidl_next::IntoNatural for NodeDeprecatedGetAttrResponse {
12303        type Natural = crate::natural::NodeDeprecatedGetAttrResponse;
12304    }
12305
12306    /// The wire type corresponding to [`NodeDeprecatedSetAttrRequest`].
12307    #[derive(Clone, Debug)]
12308    #[repr(C)]
12309    pub struct NodeDeprecatedSetAttrRequest {
12310        pub flags: crate::wire::NodeAttributeFlags,
12311
12312        pub attributes: crate::wire::NodeAttributes,
12313    }
12314
12315    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrRequest>(), 64);
12316    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrRequest>(), 8);
12317
12318    static_assertions::const_assert_eq!(
12319        std::mem::offset_of!(NodeDeprecatedSetAttrRequest, flags),
12320        0
12321    );
12322
12323    static_assertions::const_assert_eq!(
12324        std::mem::offset_of!(NodeDeprecatedSetAttrRequest, attributes),
12325        8
12326    );
12327
12328    impl ::fidl_next::Constrained for NodeDeprecatedSetAttrRequest {
12329        type Constraint = ();
12330
12331        fn validate(
12332            _: ::fidl_next::Slot<'_, Self>,
12333            _: Self::Constraint,
12334        ) -> Result<(), ::fidl_next::ValidationError> {
12335            Ok(())
12336        }
12337    }
12338
12339    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrRequest {
12340        type Narrowed<'de> = NodeDeprecatedSetAttrRequest;
12341
12342        #[inline]
12343        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12344            ::fidl_next::munge! {
12345                let Self {
12346                    flags,
12347                    attributes,
12348
12349                } = &mut *out_;
12350            }
12351
12352            ::fidl_next::Wire::zero_padding(flags);
12353
12354            ::fidl_next::Wire::zero_padding(attributes);
12355
12356            unsafe {
12357                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
12358            }
12359        }
12360    }
12361
12362    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrRequest
12363    where
12364        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12365    {
12366        fn decode(
12367            slot_: ::fidl_next::Slot<'_, Self>,
12368            decoder_: &mut ___D,
12369            _: (),
12370        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12371            if slot_.as_bytes()[4..8] != [0u8; 4] {
12372                return Err(::fidl_next::DecodeError::InvalidPadding);
12373            }
12374
12375            ::fidl_next::munge! {
12376                let Self {
12377                    mut flags,
12378                    mut attributes,
12379
12380                } = slot_;
12381            }
12382
12383            let _field = flags.as_mut();
12384
12385            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12386
12387            let _field = attributes.as_mut();
12388
12389            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
12390
12391            Ok(())
12392        }
12393    }
12394
12395    impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrRequest {
12396        type Natural = crate::natural::NodeDeprecatedSetAttrRequest;
12397    }
12398
12399    /// The wire type corresponding to [`NodeDeprecatedSetAttrResponse`].
12400    #[derive(Clone, Debug)]
12401    #[repr(C)]
12402    pub struct NodeDeprecatedSetAttrResponse {
12403        pub s: ::fidl_next::wire::fuchsia::Status,
12404    }
12405
12406    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrResponse>(), 4);
12407    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrResponse>(), 4);
12408
12409    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetAttrResponse, s), 0);
12410
12411    impl ::fidl_next::Constrained for NodeDeprecatedSetAttrResponse {
12412        type Constraint = ();
12413
12414        fn validate(
12415            _: ::fidl_next::Slot<'_, Self>,
12416            _: Self::Constraint,
12417        ) -> Result<(), ::fidl_next::ValidationError> {
12418            Ok(())
12419        }
12420    }
12421
12422    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrResponse {
12423        type Narrowed<'de> = NodeDeprecatedSetAttrResponse;
12424
12425        #[inline]
12426        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12427            ::fidl_next::munge! {
12428                let Self {
12429                    s,
12430
12431                } = &mut *out_;
12432            }
12433
12434            ::fidl_next::Wire::zero_padding(s);
12435        }
12436    }
12437
12438    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrResponse
12439    where
12440        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12441    {
12442        fn decode(
12443            slot_: ::fidl_next::Slot<'_, Self>,
12444            decoder_: &mut ___D,
12445            _: (),
12446        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12447            ::fidl_next::munge! {
12448                let Self {
12449                    mut s,
12450
12451                } = slot_;
12452            }
12453
12454            let _field = s.as_mut();
12455
12456            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12457
12458            Ok(())
12459        }
12460    }
12461
12462    impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrResponse {
12463        type Natural = crate::natural::NodeDeprecatedSetAttrResponse;
12464    }
12465
12466    /// The wire type corresponding to [`NodeDeprecatedGetFlagsResponse`].
12467    #[derive(Clone, Debug)]
12468    #[repr(C)]
12469    pub struct NodeDeprecatedGetFlagsResponse {
12470        pub s: ::fidl_next::wire::fuchsia::Status,
12471
12472        pub flags: crate::wire::OpenFlags,
12473    }
12474
12475    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetFlagsResponse>(), 8);
12476    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetFlagsResponse>(), 4);
12477
12478    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, s), 0);
12479
12480    static_assertions::const_assert_eq!(
12481        std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, flags),
12482        4
12483    );
12484
12485    impl ::fidl_next::Constrained for NodeDeprecatedGetFlagsResponse {
12486        type Constraint = ();
12487
12488        fn validate(
12489            _: ::fidl_next::Slot<'_, Self>,
12490            _: Self::Constraint,
12491        ) -> Result<(), ::fidl_next::ValidationError> {
12492            Ok(())
12493        }
12494    }
12495
12496    unsafe impl ::fidl_next::Wire for NodeDeprecatedGetFlagsResponse {
12497        type Narrowed<'de> = NodeDeprecatedGetFlagsResponse;
12498
12499        #[inline]
12500        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12501            ::fidl_next::munge! {
12502                let Self {
12503                    s,
12504                    flags,
12505
12506                } = &mut *out_;
12507            }
12508
12509            ::fidl_next::Wire::zero_padding(s);
12510
12511            ::fidl_next::Wire::zero_padding(flags);
12512        }
12513    }
12514
12515    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetFlagsResponse
12516    where
12517        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12518    {
12519        fn decode(
12520            slot_: ::fidl_next::Slot<'_, Self>,
12521            decoder_: &mut ___D,
12522            _: (),
12523        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12524            ::fidl_next::munge! {
12525                let Self {
12526                    mut s,
12527                    mut flags,
12528
12529                } = slot_;
12530            }
12531
12532            let _field = s.as_mut();
12533
12534            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12535
12536            let _field = flags.as_mut();
12537
12538            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12539
12540            Ok(())
12541        }
12542    }
12543
12544    impl ::fidl_next::IntoNatural for NodeDeprecatedGetFlagsResponse {
12545        type Natural = crate::natural::NodeDeprecatedGetFlagsResponse;
12546    }
12547
12548    /// The wire type corresponding to [`NodeDeprecatedSetFlagsRequest`].
12549    #[derive(Clone, Debug)]
12550    #[repr(C)]
12551    pub struct NodeDeprecatedSetFlagsRequest {
12552        pub flags: crate::wire::OpenFlags,
12553    }
12554
12555    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsRequest>(), 4);
12556    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsRequest>(), 4);
12557
12558    static_assertions::const_assert_eq!(
12559        std::mem::offset_of!(NodeDeprecatedSetFlagsRequest, flags),
12560        0
12561    );
12562
12563    impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsRequest {
12564        type Constraint = ();
12565
12566        fn validate(
12567            _: ::fidl_next::Slot<'_, Self>,
12568            _: Self::Constraint,
12569        ) -> Result<(), ::fidl_next::ValidationError> {
12570            Ok(())
12571        }
12572    }
12573
12574    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsRequest {
12575        type Narrowed<'de> = NodeDeprecatedSetFlagsRequest;
12576
12577        #[inline]
12578        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12579            ::fidl_next::munge! {
12580                let Self {
12581                    flags,
12582
12583                } = &mut *out_;
12584            }
12585
12586            ::fidl_next::Wire::zero_padding(flags);
12587        }
12588    }
12589
12590    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsRequest
12591    where
12592        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12593    {
12594        fn decode(
12595            slot_: ::fidl_next::Slot<'_, Self>,
12596            decoder_: &mut ___D,
12597            _: (),
12598        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12599            ::fidl_next::munge! {
12600                let Self {
12601                    mut flags,
12602
12603                } = slot_;
12604            }
12605
12606            let _field = flags.as_mut();
12607
12608            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12609
12610            Ok(())
12611        }
12612    }
12613
12614    impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsRequest {
12615        type Natural = crate::natural::NodeDeprecatedSetFlagsRequest;
12616    }
12617
12618    /// The wire type corresponding to [`NodeDeprecatedSetFlagsResponse`].
12619    #[derive(Clone, Debug)]
12620    #[repr(C)]
12621    pub struct NodeDeprecatedSetFlagsResponse {
12622        pub s: ::fidl_next::wire::fuchsia::Status,
12623    }
12624
12625    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsResponse>(), 4);
12626    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsResponse>(), 4);
12627
12628    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetFlagsResponse, s), 0);
12629
12630    impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsResponse {
12631        type Constraint = ();
12632
12633        fn validate(
12634            _: ::fidl_next::Slot<'_, Self>,
12635            _: Self::Constraint,
12636        ) -> Result<(), ::fidl_next::ValidationError> {
12637            Ok(())
12638        }
12639    }
12640
12641    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsResponse {
12642        type Narrowed<'de> = NodeDeprecatedSetFlagsResponse;
12643
12644        #[inline]
12645        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12646            ::fidl_next::munge! {
12647                let Self {
12648                    s,
12649
12650                } = &mut *out_;
12651            }
12652
12653            ::fidl_next::Wire::zero_padding(s);
12654        }
12655    }
12656
12657    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsResponse
12658    where
12659        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12660    {
12661        fn decode(
12662            slot_: ::fidl_next::Slot<'_, Self>,
12663            decoder_: &mut ___D,
12664            _: (),
12665        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12666            ::fidl_next::munge! {
12667                let Self {
12668                    mut s,
12669
12670                } = slot_;
12671            }
12672
12673            let _field = s.as_mut();
12674
12675            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12676
12677            Ok(())
12678        }
12679    }
12680
12681    impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsResponse {
12682        type Natural = crate::natural::NodeDeprecatedSetFlagsResponse;
12683    }
12684
12685    /// The wire type corresponding to [`Flags`](crate::natural::Flags).
12686    #[derive(Clone, Copy, Debug)]
12687    #[repr(transparent)]
12688    pub struct Flags {
12689        pub(crate) value: ::fidl_next::wire::Uint64,
12690    }
12691
12692    impl ::fidl_next::Constrained for Flags {
12693        type Constraint = ();
12694
12695        fn validate(
12696            _: ::fidl_next::Slot<'_, Self>,
12697            _: Self::Constraint,
12698        ) -> Result<(), ::fidl_next::ValidationError> {
12699            Ok(())
12700        }
12701    }
12702
12703    unsafe impl ::fidl_next::Wire for Flags {
12704        type Narrowed<'de> = Self;
12705
12706        #[inline]
12707        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12708            // Wire bits have no padding
12709        }
12710    }
12711
12712    unsafe impl<___D> ::fidl_next::Decode<___D> for Flags
12713    where
12714        ___D: ?Sized,
12715    {
12716        fn decode(
12717            slot: ::fidl_next::Slot<'_, Self>,
12718            _: &mut ___D,
12719            _: (),
12720        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12721            Ok(())
12722        }
12723    }
12724
12725    impl ::core::convert::From<crate::natural::Flags> for Flags {
12726        fn from(natural: crate::natural::Flags) -> Self {
12727            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
12728        }
12729    }
12730
12731    impl ::fidl_next::IntoNatural for Flags {
12732        type Natural = crate::natural::Flags;
12733    }
12734
12735    /// The wire type corresponding to [`NodeGetFlagsResponse`].
12736    #[derive(Clone, Debug)]
12737    #[repr(C)]
12738    pub struct NodeGetFlagsResponse {
12739        pub flags: crate::wire::Flags,
12740    }
12741
12742    static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetFlagsResponse>(), 8);
12743    static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetFlagsResponse>(), 8);
12744
12745    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetFlagsResponse, flags), 0);
12746
12747    impl ::fidl_next::Constrained for NodeGetFlagsResponse {
12748        type Constraint = ();
12749
12750        fn validate(
12751            _: ::fidl_next::Slot<'_, Self>,
12752            _: Self::Constraint,
12753        ) -> Result<(), ::fidl_next::ValidationError> {
12754            Ok(())
12755        }
12756    }
12757
12758    unsafe impl ::fidl_next::Wire for NodeGetFlagsResponse {
12759        type Narrowed<'de> = NodeGetFlagsResponse;
12760
12761        #[inline]
12762        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12763            ::fidl_next::munge! {
12764                let Self {
12765                    flags,
12766
12767                } = &mut *out_;
12768            }
12769
12770            ::fidl_next::Wire::zero_padding(flags);
12771        }
12772    }
12773
12774    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetFlagsResponse
12775    where
12776        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12777    {
12778        fn decode(
12779            slot_: ::fidl_next::Slot<'_, Self>,
12780            decoder_: &mut ___D,
12781            _: (),
12782        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12783            ::fidl_next::munge! {
12784                let Self {
12785                    mut flags,
12786
12787                } = slot_;
12788            }
12789
12790            let _field = flags.as_mut();
12791
12792            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12793
12794            Ok(())
12795        }
12796    }
12797
12798    impl ::fidl_next::IntoNatural for NodeGetFlagsResponse {
12799        type Natural = crate::natural::NodeGetFlagsResponse;
12800    }
12801
12802    /// The wire type corresponding to [`NodeSetFlagsRequest`].
12803    #[derive(Clone, Debug)]
12804    #[repr(C)]
12805    pub struct NodeSetFlagsRequest {
12806        pub flags: crate::wire::Flags,
12807    }
12808
12809    static_assertions::const_assert_eq!(std::mem::size_of::<NodeSetFlagsRequest>(), 8);
12810    static_assertions::const_assert_eq!(std::mem::align_of::<NodeSetFlagsRequest>(), 8);
12811
12812    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeSetFlagsRequest, flags), 0);
12813
12814    impl ::fidl_next::Constrained for NodeSetFlagsRequest {
12815        type Constraint = ();
12816
12817        fn validate(
12818            _: ::fidl_next::Slot<'_, Self>,
12819            _: Self::Constraint,
12820        ) -> Result<(), ::fidl_next::ValidationError> {
12821            Ok(())
12822        }
12823    }
12824
12825    unsafe impl ::fidl_next::Wire for NodeSetFlagsRequest {
12826        type Narrowed<'de> = NodeSetFlagsRequest;
12827
12828        #[inline]
12829        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12830            ::fidl_next::munge! {
12831                let Self {
12832                    flags,
12833
12834                } = &mut *out_;
12835            }
12836
12837            ::fidl_next::Wire::zero_padding(flags);
12838        }
12839    }
12840
12841    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetFlagsRequest
12842    where
12843        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12844    {
12845        fn decode(
12846            slot_: ::fidl_next::Slot<'_, Self>,
12847            decoder_: &mut ___D,
12848            _: (),
12849        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12850            ::fidl_next::munge! {
12851                let Self {
12852                    mut flags,
12853
12854                } = slot_;
12855            }
12856
12857            let _field = flags.as_mut();
12858
12859            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12860
12861            Ok(())
12862        }
12863    }
12864
12865    impl ::fidl_next::IntoNatural for NodeSetFlagsRequest {
12866        type Natural = crate::natural::NodeSetFlagsRequest;
12867    }
12868
12869    /// The wire type corresponding to [`EmptyStruct`].
12870    pub type EmptyStruct = ::fidl_next::wire::Unit;
12871
12872    /// The wire type corresponding to [`SelinuxContext`].
12873    #[repr(transparent)]
12874    pub struct SelinuxContext<'de> {
12875        pub(crate) raw: ::fidl_next::wire::Union,
12876        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12877    }
12878
12879    impl<'de> Drop for SelinuxContext<'de> {
12880        fn drop(&mut self) {
12881            match self.raw.ordinal() {
12882                1 => {
12883                    let _ = unsafe {
12884                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
12885                    };
12886                }
12887
12888                2 => {
12889                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::EmptyStruct>() };
12890                }
12891
12892                _ => (),
12893            }
12894        }
12895    }
12896
12897    impl ::fidl_next::Constrained for SelinuxContext<'_> {
12898        type Constraint = ();
12899
12900        fn validate(
12901            _: ::fidl_next::Slot<'_, Self>,
12902            _: Self::Constraint,
12903        ) -> Result<(), ::fidl_next::ValidationError> {
12904            Ok(())
12905        }
12906    }
12907
12908    unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
12909        type Narrowed<'de> = SelinuxContext<'de>;
12910
12911        #[inline]
12912        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12913            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12914            ::fidl_next::wire::Union::zero_padding(raw);
12915        }
12916    }
12917
12918    pub mod selinux_context {
12919        pub enum Ref<'de> {
12920            Data(&'de ::fidl_next::wire::Vector<'de, u8>),
12921
12922            UseExtendedAttributes(&'de crate::wire::EmptyStruct),
12923
12924            UnknownOrdinal_(u64),
12925        }
12926
12927        pub enum Value<'de> {
12928            Data(::fidl_next::wire::Vector<'de, u8>),
12929
12930            UseExtendedAttributes(crate::wire::EmptyStruct),
12931
12932            UnknownOrdinal_(u64),
12933        }
12934    }
12935
12936    impl<'de> SelinuxContext<'de> {
12937        pub fn as_ref(&self) -> crate::wire::selinux_context::Ref<'_> {
12938            match self.raw.ordinal() {
12939                1 => crate::wire::selinux_context::Ref::Data(unsafe {
12940                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
12941                }),
12942
12943                2 => crate::wire::selinux_context::Ref::UseExtendedAttributes(unsafe {
12944                    self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
12945                }),
12946
12947                unknown => crate::wire::selinux_context::Ref::UnknownOrdinal_(unknown),
12948            }
12949        }
12950
12951        pub fn into_inner(self) -> crate::wire::selinux_context::Value<'de> {
12952            let this = ::core::mem::ManuallyDrop::new(self);
12953
12954            match this.raw.ordinal() {
12955                1 => crate::wire::selinux_context::Value::Data(unsafe {
12956                    this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
12957                }),
12958
12959                2 => crate::wire::selinux_context::Value::UseExtendedAttributes(unsafe {
12960                    this.raw.get().read_unchecked::<crate::wire::EmptyStruct>()
12961                }),
12962
12963                unknown => crate::wire::selinux_context::Value::UnknownOrdinal_(unknown),
12964            }
12965        }
12966    }
12967
12968    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
12969    where
12970        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12971        ___D: ::fidl_next::Decoder<'de>,
12972    {
12973        fn decode(
12974            mut slot: ::fidl_next::Slot<'_, Self>,
12975            decoder: &mut ___D,
12976            _: (),
12977        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12978            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12979            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
12980                1 => {
12981                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
12982                        raw,
12983                        decoder,
12984                        (256, ()),
12985                    )?
12986                }
12987
12988                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
12989                    raw,
12990                    decoder,
12991                    (),
12992                )?,
12993
12994                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
12995            }
12996
12997            Ok(())
12998        }
12999    }
13000
13001    impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
13002        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
13003            match self.raw.ordinal() {
13004                1 => unsafe {
13005                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
13006                },
13007                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>().fmt(f) },
13008                _ => unsafe { ::core::hint::unreachable_unchecked() },
13009            }
13010        }
13011    }
13012
13013    impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
13014        type Natural = crate::natural::SelinuxContext;
13015    }
13016
13017    /// The wire type corresponding to [`MutableNodeAttributes`].
13018    #[repr(C)]
13019    pub struct MutableNodeAttributes<'de> {
13020        pub(crate) table: ::fidl_next::wire::Table<'de>,
13021    }
13022
13023    impl<'de> Drop for MutableNodeAttributes<'de> {
13024        fn drop(&mut self) {
13025            let _ = self
13026                .table
13027                .get(1)
13028                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13029
13030            let _ = self
13031                .table
13032                .get(2)
13033                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13034
13035            let _ = self
13036                .table
13037                .get(3)
13038                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13039
13040            let _ = self
13041                .table
13042                .get(4)
13043                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13044
13045            let _ = self
13046                .table
13047                .get(5)
13048                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13049
13050            let _ = self
13051                .table
13052                .get(6)
13053                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13054
13055            let _ = self
13056                .table
13057                .get(7)
13058                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13059
13060            let _ = self.table.get(8).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
13061
13062            let _ = self.table.get(9).map(|envelope| unsafe {
13063                envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
13064            });
13065
13066            let _ =
13067                self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 16]>() });
13068        }
13069    }
13070
13071    impl ::fidl_next::Constrained for MutableNodeAttributes<'_> {
13072        type Constraint = ();
13073
13074        fn validate(
13075            _: ::fidl_next::Slot<'_, Self>,
13076            _: Self::Constraint,
13077        ) -> Result<(), ::fidl_next::ValidationError> {
13078            Ok(())
13079        }
13080    }
13081
13082    unsafe impl ::fidl_next::Wire for MutableNodeAttributes<'static> {
13083        type Narrowed<'de> = MutableNodeAttributes<'de>;
13084
13085        #[inline]
13086        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13087            ::fidl_next::munge!(let Self { table } = out);
13088            ::fidl_next::wire::Table::zero_padding(table);
13089        }
13090    }
13091
13092    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for MutableNodeAttributes<'de>
13093    where
13094        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13095    {
13096        fn decode(
13097            slot: ::fidl_next::Slot<'_, Self>,
13098            decoder: &mut ___D,
13099            _: (),
13100        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13101            ::fidl_next::munge!(let Self { table } = slot);
13102
13103            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13104                match ordinal {
13105                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13106
13107                    1 => {
13108                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13109                            slot.as_mut(),
13110                            decoder,
13111                            (),
13112                        )?;
13113
13114                        Ok(())
13115                    }
13116
13117                    2 => {
13118                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13119                            slot.as_mut(),
13120                            decoder,
13121                            (),
13122                        )?;
13123
13124                        Ok(())
13125                    }
13126
13127                    3 => {
13128                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13129                            slot.as_mut(),
13130                            decoder,
13131                            (),
13132                        )?;
13133
13134                        Ok(())
13135                    }
13136
13137                    4 => {
13138                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13139                            slot.as_mut(),
13140                            decoder,
13141                            (),
13142                        )?;
13143
13144                        Ok(())
13145                    }
13146
13147                    5 => {
13148                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13149                            slot.as_mut(),
13150                            decoder,
13151                            (),
13152                        )?;
13153
13154                        Ok(())
13155                    }
13156
13157                    6 => {
13158                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13159                            slot.as_mut(),
13160                            decoder,
13161                            (),
13162                        )?;
13163
13164                        Ok(())
13165                    }
13166
13167                    7 => {
13168                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13169                            slot.as_mut(),
13170                            decoder,
13171                            (),
13172                        )?;
13173
13174                        Ok(())
13175                    }
13176
13177                    8 => {
13178                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
13179                            slot.as_mut(),
13180                            decoder,
13181                            (),
13182                        )?;
13183
13184                        Ok(())
13185                    }
13186
13187                    9 => {
13188                        ::fidl_next::wire::Envelope::decode_as::<
13189                            ___D,
13190                            crate::wire::SelinuxContext<'de>,
13191                        >(slot.as_mut(), decoder, ())?;
13192
13193                        Ok(())
13194                    }
13195
13196                    10 => {
13197                        ::fidl_next::wire::Envelope::decode_as::<___D, [u8; 16]>(
13198                            slot.as_mut(),
13199                            decoder,
13200                            (),
13201                        )?;
13202
13203                        Ok(())
13204                    }
13205
13206                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13207                }
13208            })
13209        }
13210    }
13211
13212    impl<'de> MutableNodeAttributes<'de> {
13213        pub fn creation_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13214            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13215        }
13216
13217        pub fn take_creation_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13218            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13219        }
13220
13221        pub fn modification_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13222            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13223        }
13224
13225        pub fn take_modification_time(
13226            &mut self,
13227        ) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13228            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13229        }
13230
13231        pub fn mode(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13232            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
13233        }
13234
13235        pub fn take_mode(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13236            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
13237        }
13238
13239        pub fn uid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13240            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
13241        }
13242
13243        pub fn take_uid(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13244            unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
13245        }
13246
13247        pub fn gid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13248            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
13249        }
13250
13251        pub fn take_gid(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13252            unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
13253        }
13254
13255        pub fn rdev(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13256            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
13257        }
13258
13259        pub fn take_rdev(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13260            unsafe { Some(self.table.get_mut(6)?.take_unchecked()) }
13261        }
13262
13263        pub fn access_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13264            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
13265        }
13266
13267        pub fn take_access_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13268            unsafe { Some(self.table.get_mut(7)?.take_unchecked()) }
13269        }
13270
13271        pub fn casefold(&self) -> ::core::option::Option<&bool> {
13272            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
13273        }
13274
13275        pub fn take_casefold(&mut self) -> ::core::option::Option<bool> {
13276            unsafe { Some(self.table.get_mut(8)?.take_unchecked()) }
13277        }
13278
13279        pub fn selinux_context(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
13280            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
13281        }
13282
13283        pub fn take_selinux_context(
13284            &mut self,
13285        ) -> ::core::option::Option<crate::wire::SelinuxContext<'de>> {
13286            unsafe { Some(self.table.get_mut(9)?.take_unchecked()) }
13287        }
13288
13289        pub fn wrapping_key_id(&self) -> ::core::option::Option<&[u8; 16]> {
13290            unsafe { Some(self.table.get(10)?.deref_unchecked()) }
13291        }
13292
13293        pub fn take_wrapping_key_id(&mut self) -> ::core::option::Option<[u8; 16]> {
13294            unsafe { Some(self.table.get_mut(10)?.take_unchecked()) }
13295        }
13296    }
13297
13298    impl<'de> ::core::fmt::Debug for MutableNodeAttributes<'de> {
13299        fn fmt(
13300            &self,
13301            f: &mut ::core::fmt::Formatter<'_>,
13302        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13303            f.debug_struct("MutableNodeAttributes")
13304                .field("creation_time", &self.creation_time())
13305                .field("modification_time", &self.modification_time())
13306                .field("mode", &self.mode())
13307                .field("uid", &self.uid())
13308                .field("gid", &self.gid())
13309                .field("rdev", &self.rdev())
13310                .field("access_time", &self.access_time())
13311                .field("casefold", &self.casefold())
13312                .field("selinux_context", &self.selinux_context())
13313                .field("wrapping_key_id", &self.wrapping_key_id())
13314                .finish()
13315        }
13316    }
13317
13318    impl<'de> ::fidl_next::IntoNatural for MutableNodeAttributes<'de> {
13319        type Natural = crate::natural::MutableNodeAttributes;
13320    }
13321
13322    /// The wire type corresponding to [`NodeProtocolKinds`](crate::natural::NodeProtocolKinds).
13323    #[derive(Clone, Copy, Debug)]
13324    #[repr(transparent)]
13325    pub struct NodeProtocolKinds {
13326        pub(crate) value: ::fidl_next::wire::Uint64,
13327    }
13328
13329    impl ::fidl_next::Constrained for NodeProtocolKinds {
13330        type Constraint = ();
13331
13332        fn validate(
13333            _: ::fidl_next::Slot<'_, Self>,
13334            _: Self::Constraint,
13335        ) -> Result<(), ::fidl_next::ValidationError> {
13336            Ok(())
13337        }
13338    }
13339
13340    unsafe impl ::fidl_next::Wire for NodeProtocolKinds {
13341        type Narrowed<'de> = Self;
13342
13343        #[inline]
13344        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13345            // Wire bits have no padding
13346        }
13347    }
13348
13349    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeProtocolKinds
13350    where
13351        ___D: ?Sized,
13352    {
13353        fn decode(
13354            slot: ::fidl_next::Slot<'_, Self>,
13355            _: &mut ___D,
13356            _: (),
13357        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13358            Ok(())
13359        }
13360    }
13361
13362    impl ::core::convert::From<crate::natural::NodeProtocolKinds> for NodeProtocolKinds {
13363        fn from(natural: crate::natural::NodeProtocolKinds) -> Self {
13364            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
13365        }
13366    }
13367
13368    impl ::fidl_next::IntoNatural for NodeProtocolKinds {
13369        type Natural = crate::natural::NodeProtocolKinds;
13370    }
13371
13372    /// The wire type corresponding to [`HashAlgorithm`].
13373    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
13374    #[repr(transparent)]
13375    pub struct HashAlgorithm {
13376        pub(crate) value: u8,
13377    }
13378
13379    impl ::fidl_next::Constrained for HashAlgorithm {
13380        type Constraint = ();
13381
13382        fn validate(
13383            _: ::fidl_next::Slot<'_, Self>,
13384            _: Self::Constraint,
13385        ) -> Result<(), ::fidl_next::ValidationError> {
13386            Ok(())
13387        }
13388    }
13389
13390    unsafe impl ::fidl_next::Wire for HashAlgorithm {
13391        type Narrowed<'de> = Self;
13392
13393        #[inline]
13394        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13395            // Wire enums have no padding
13396        }
13397    }
13398
13399    impl HashAlgorithm {
13400        pub const SHA256: HashAlgorithm = HashAlgorithm { value: 1 };
13401
13402        pub const SHA512: HashAlgorithm = HashAlgorithm { value: 2 };
13403    }
13404
13405    unsafe impl<___D> ::fidl_next::Decode<___D> for HashAlgorithm
13406    where
13407        ___D: ?Sized,
13408    {
13409        fn decode(
13410            slot: ::fidl_next::Slot<'_, Self>,
13411            _: &mut ___D,
13412            _: (),
13413        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13414            Ok(())
13415        }
13416    }
13417
13418    impl ::core::convert::From<crate::natural::HashAlgorithm> for HashAlgorithm {
13419        fn from(natural: crate::natural::HashAlgorithm) -> Self {
13420            match natural {
13421                crate::natural::HashAlgorithm::Sha256 => HashAlgorithm::SHA256,
13422
13423                crate::natural::HashAlgorithm::Sha512 => HashAlgorithm::SHA512,
13424
13425                crate::natural::HashAlgorithm::UnknownOrdinal_(value) => {
13426                    HashAlgorithm { value: u8::from(value) }
13427                }
13428            }
13429        }
13430    }
13431
13432    impl ::fidl_next::IntoNatural for HashAlgorithm {
13433        type Natural = crate::natural::HashAlgorithm;
13434    }
13435
13436    /// The wire type corresponding to [`VerificationOptions`].
13437    #[repr(C)]
13438    pub struct VerificationOptions<'de> {
13439        pub(crate) table: ::fidl_next::wire::Table<'de>,
13440    }
13441
13442    impl<'de> Drop for VerificationOptions<'de> {
13443        fn drop(&mut self) {
13444            let _ = self
13445                .table
13446                .get(1)
13447                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::HashAlgorithm>() });
13448
13449            let _ = self.table.get(2).map(|envelope| unsafe {
13450                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
13451            });
13452        }
13453    }
13454
13455    impl ::fidl_next::Constrained for VerificationOptions<'_> {
13456        type Constraint = ();
13457
13458        fn validate(
13459            _: ::fidl_next::Slot<'_, Self>,
13460            _: Self::Constraint,
13461        ) -> Result<(), ::fidl_next::ValidationError> {
13462            Ok(())
13463        }
13464    }
13465
13466    unsafe impl ::fidl_next::Wire for VerificationOptions<'static> {
13467        type Narrowed<'de> = VerificationOptions<'de>;
13468
13469        #[inline]
13470        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13471            ::fidl_next::munge!(let Self { table } = out);
13472            ::fidl_next::wire::Table::zero_padding(table);
13473        }
13474    }
13475
13476    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VerificationOptions<'de>
13477    where
13478        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13479    {
13480        fn decode(
13481            slot: ::fidl_next::Slot<'_, Self>,
13482            decoder: &mut ___D,
13483            _: (),
13484        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13485            ::fidl_next::munge!(let Self { table } = slot);
13486
13487            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13488                match ordinal {
13489                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13490
13491                    1 => {
13492                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::HashAlgorithm>(
13493                            slot.as_mut(),
13494                            decoder,
13495                            (),
13496                        )?;
13497
13498                        Ok(())
13499                    }
13500
13501                    2 => {
13502                        ::fidl_next::wire::Envelope::decode_as::<
13503                            ___D,
13504                            ::fidl_next::wire::Vector<'de, u8>,
13505                        >(slot.as_mut(), decoder, (32, ()))?;
13506
13507                        let value = unsafe {
13508                            slot.deref_unchecked()
13509                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
13510                        };
13511
13512                        if value.len() > 32 {
13513                            return Err(::fidl_next::DecodeError::VectorTooLong {
13514                                size: value.len() as u64,
13515                                limit: 32,
13516                            });
13517                        }
13518
13519                        Ok(())
13520                    }
13521
13522                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13523                }
13524            })
13525        }
13526    }
13527
13528    impl<'de> VerificationOptions<'de> {
13529        pub fn hash_algorithm(&self) -> ::core::option::Option<&crate::wire::HashAlgorithm> {
13530            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13531        }
13532
13533        pub fn take_hash_algorithm(
13534            &mut self,
13535        ) -> ::core::option::Option<crate::wire::HashAlgorithm> {
13536            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13537        }
13538
13539        pub fn salt(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
13540            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13541        }
13542
13543        pub fn take_salt(&mut self) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
13544            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13545        }
13546    }
13547
13548    impl<'de> ::core::fmt::Debug for VerificationOptions<'de> {
13549        fn fmt(
13550            &self,
13551            f: &mut ::core::fmt::Formatter<'_>,
13552        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13553            f.debug_struct("VerificationOptions")
13554                .field("hash_algorithm", &self.hash_algorithm())
13555                .field("salt", &self.salt())
13556                .finish()
13557        }
13558    }
13559
13560    impl<'de> ::fidl_next::IntoNatural for VerificationOptions<'de> {
13561        type Natural = crate::natural::VerificationOptions;
13562    }
13563
13564    /// The wire type corresponding to [`ImmutableNodeAttributes`].
13565    #[repr(C)]
13566    pub struct ImmutableNodeAttributes<'de> {
13567        pub(crate) table: ::fidl_next::wire::Table<'de>,
13568    }
13569
13570    impl<'de> Drop for ImmutableNodeAttributes<'de> {
13571        fn drop(&mut self) {
13572            let _ = self.table.get(1).map(|envelope| unsafe {
13573                envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
13574            });
13575
13576            let _ = self
13577                .table
13578                .get(2)
13579                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
13580
13581            let _ = self
13582                .table
13583                .get(3)
13584                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13585
13586            let _ = self
13587                .table
13588                .get(4)
13589                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13590
13591            let _ = self
13592                .table
13593                .get(5)
13594                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13595
13596            let _ = self
13597                .table
13598                .get(6)
13599                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13600
13601            let _ = self
13602                .table
13603                .get(7)
13604                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13605
13606            let _ = self.table.get(8).map(|envelope| unsafe {
13607                envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
13608            });
13609
13610            let _ = self.table.get(9).map(|envelope| unsafe {
13611                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
13612            });
13613
13614            let _ = self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
13615        }
13616    }
13617
13618    impl ::fidl_next::Constrained for ImmutableNodeAttributes<'_> {
13619        type Constraint = ();
13620
13621        fn validate(
13622            _: ::fidl_next::Slot<'_, Self>,
13623            _: Self::Constraint,
13624        ) -> Result<(), ::fidl_next::ValidationError> {
13625            Ok(())
13626        }
13627    }
13628
13629    unsafe impl ::fidl_next::Wire for ImmutableNodeAttributes<'static> {
13630        type Narrowed<'de> = ImmutableNodeAttributes<'de>;
13631
13632        #[inline]
13633        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13634            ::fidl_next::munge!(let Self { table } = out);
13635            ::fidl_next::wire::Table::zero_padding(table);
13636        }
13637    }
13638
13639    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ImmutableNodeAttributes<'de>
13640    where
13641        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13642    {
13643        fn decode(
13644            slot: ::fidl_next::Slot<'_, Self>,
13645            decoder: &mut ___D,
13646            _: (),
13647        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13648            ::fidl_next::munge!(let Self { table } = slot);
13649
13650            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13651                match ordinal {
13652                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13653
13654                    1 => {
13655                        ::fidl_next::wire::Envelope::decode_as::<
13656                            ___D,
13657                            crate::wire::NodeProtocolKinds,
13658                        >(slot.as_mut(), decoder, ())?;
13659
13660                        Ok(())
13661                    }
13662
13663                    2 => {
13664                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
13665                            slot.as_mut(),
13666                            decoder,
13667                            (),
13668                        )?;
13669
13670                        Ok(())
13671                    }
13672
13673                    3 => {
13674                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13675                            slot.as_mut(),
13676                            decoder,
13677                            (),
13678                        )?;
13679
13680                        Ok(())
13681                    }
13682
13683                    4 => {
13684                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13685                            slot.as_mut(),
13686                            decoder,
13687                            (),
13688                        )?;
13689
13690                        Ok(())
13691                    }
13692
13693                    5 => {
13694                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13695                            slot.as_mut(),
13696                            decoder,
13697                            (),
13698                        )?;
13699
13700                        Ok(())
13701                    }
13702
13703                    6 => {
13704                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13705                            slot.as_mut(),
13706                            decoder,
13707                            (),
13708                        )?;
13709
13710                        Ok(())
13711                    }
13712
13713                    7 => {
13714                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13715                            slot.as_mut(),
13716                            decoder,
13717                            (),
13718                        )?;
13719
13720                        Ok(())
13721                    }
13722
13723                    8 => {
13724                        ::fidl_next::wire::Envelope::decode_as::<
13725                            ___D,
13726                            crate::wire::VerificationOptions<'de>,
13727                        >(slot.as_mut(), decoder, ())?;
13728
13729                        Ok(())
13730                    }
13731
13732                    9 => {
13733                        ::fidl_next::wire::Envelope::decode_as::<
13734                            ___D,
13735                            ::fidl_next::wire::Vector<'de, u8>,
13736                        >(slot.as_mut(), decoder, (64, ()))?;
13737
13738                        let value = unsafe {
13739                            slot.deref_unchecked()
13740                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
13741                        };
13742
13743                        if value.len() > 64 {
13744                            return Err(::fidl_next::DecodeError::VectorTooLong {
13745                                size: value.len() as u64,
13746                                limit: 64,
13747                            });
13748                        }
13749
13750                        Ok(())
13751                    }
13752
13753                    10 => {
13754                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
13755                            slot.as_mut(),
13756                            decoder,
13757                            (),
13758                        )?;
13759
13760                        Ok(())
13761                    }
13762
13763                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13764                }
13765            })
13766        }
13767    }
13768
13769    impl<'de> ImmutableNodeAttributes<'de> {
13770        pub fn protocols(&self) -> ::core::option::Option<&crate::wire::NodeProtocolKinds> {
13771            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13772        }
13773
13774        pub fn take_protocols(&mut self) -> ::core::option::Option<crate::wire::NodeProtocolKinds> {
13775            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13776        }
13777
13778        pub fn abilities(&self) -> ::core::option::Option<&crate::wire::Operations> {
13779            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13780        }
13781
13782        pub fn take_abilities(&mut self) -> ::core::option::Option<crate::wire::Operations> {
13783            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13784        }
13785
13786        pub fn content_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13787            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
13788        }
13789
13790        pub fn take_content_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13791            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
13792        }
13793
13794        pub fn storage_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13795            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
13796        }
13797
13798        pub fn take_storage_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13799            unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
13800        }
13801
13802        pub fn link_count(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13803            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
13804        }
13805
13806        pub fn take_link_count(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13807            unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
13808        }
13809
13810        pub fn id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13811            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
13812        }
13813
13814        pub fn take_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13815            unsafe { Some(self.table.get_mut(6)?.take_unchecked()) }
13816        }
13817
13818        pub fn change_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13819            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
13820        }
13821
13822        pub fn take_change_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13823            unsafe { Some(self.table.get_mut(7)?.take_unchecked()) }
13824        }
13825
13826        pub fn options(&self) -> ::core::option::Option<&crate::wire::VerificationOptions<'de>> {
13827            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
13828        }
13829
13830        pub fn take_options(
13831            &mut self,
13832        ) -> ::core::option::Option<crate::wire::VerificationOptions<'de>> {
13833            unsafe { Some(self.table.get_mut(8)?.take_unchecked()) }
13834        }
13835
13836        pub fn root_hash(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
13837            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
13838        }
13839
13840        pub fn take_root_hash(
13841            &mut self,
13842        ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
13843            unsafe { Some(self.table.get_mut(9)?.take_unchecked()) }
13844        }
13845
13846        pub fn verity_enabled(&self) -> ::core::option::Option<&bool> {
13847            unsafe { Some(self.table.get(10)?.deref_unchecked()) }
13848        }
13849
13850        pub fn take_verity_enabled(&mut self) -> ::core::option::Option<bool> {
13851            unsafe { Some(self.table.get_mut(10)?.take_unchecked()) }
13852        }
13853    }
13854
13855    impl<'de> ::core::fmt::Debug for ImmutableNodeAttributes<'de> {
13856        fn fmt(
13857            &self,
13858            f: &mut ::core::fmt::Formatter<'_>,
13859        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13860            f.debug_struct("ImmutableNodeAttributes")
13861                .field("protocols", &self.protocols())
13862                .field("abilities", &self.abilities())
13863                .field("content_size", &self.content_size())
13864                .field("storage_size", &self.storage_size())
13865                .field("link_count", &self.link_count())
13866                .field("id", &self.id())
13867                .field("change_time", &self.change_time())
13868                .field("options", &self.options())
13869                .field("root_hash", &self.root_hash())
13870                .field("verity_enabled", &self.verity_enabled())
13871                .finish()
13872        }
13873    }
13874
13875    impl<'de> ::fidl_next::IntoNatural for ImmutableNodeAttributes<'de> {
13876        type Natural = crate::natural::ImmutableNodeAttributes;
13877    }
13878
13879    /// The wire type corresponding to [`NodeAttributes2`].
13880    #[derive(Debug)]
13881    #[repr(C)]
13882    pub struct NodeAttributes2<'de> {
13883        pub mutable_attributes: crate::wire::MutableNodeAttributes<'de>,
13884
13885        pub immutable_attributes: crate::wire::ImmutableNodeAttributes<'de>,
13886    }
13887
13888    static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes2<'_>>(), 32);
13889    static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes2<'_>>(), 8);
13890
13891    static_assertions::const_assert_eq!(
13892        std::mem::offset_of!(NodeAttributes2<'_>, mutable_attributes),
13893        0
13894    );
13895
13896    static_assertions::const_assert_eq!(
13897        std::mem::offset_of!(NodeAttributes2<'_>, immutable_attributes),
13898        16
13899    );
13900
13901    impl ::fidl_next::Constrained for NodeAttributes2<'_> {
13902        type Constraint = ();
13903
13904        fn validate(
13905            _: ::fidl_next::Slot<'_, Self>,
13906            _: Self::Constraint,
13907        ) -> Result<(), ::fidl_next::ValidationError> {
13908            Ok(())
13909        }
13910    }
13911
13912    unsafe impl ::fidl_next::Wire for NodeAttributes2<'static> {
13913        type Narrowed<'de> = NodeAttributes2<'de>;
13914
13915        #[inline]
13916        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13917            ::fidl_next::munge! {
13918                let Self {
13919                    mutable_attributes,
13920                    immutable_attributes,
13921
13922                } = &mut *out_;
13923            }
13924
13925            ::fidl_next::Wire::zero_padding(mutable_attributes);
13926
13927            ::fidl_next::Wire::zero_padding(immutable_attributes);
13928        }
13929    }
13930
13931    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeAttributes2<'de>
13932    where
13933        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13934        ___D: ::fidl_next::Decoder<'de>,
13935    {
13936        fn decode(
13937            slot_: ::fidl_next::Slot<'_, Self>,
13938            decoder_: &mut ___D,
13939            _: (),
13940        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13941            ::fidl_next::munge! {
13942                let Self {
13943                    mut mutable_attributes,
13944                    mut immutable_attributes,
13945
13946                } = slot_;
13947            }
13948
13949            let _field = mutable_attributes.as_mut();
13950
13951            ::fidl_next::Decode::decode(mutable_attributes.as_mut(), decoder_, ())?;
13952
13953            let _field = immutable_attributes.as_mut();
13954
13955            ::fidl_next::Decode::decode(immutable_attributes.as_mut(), decoder_, ())?;
13956
13957            Ok(())
13958        }
13959    }
13960
13961    impl<'de> ::fidl_next::IntoNatural for NodeAttributes2<'de> {
13962        type Natural = crate::natural::NodeAttributes2;
13963    }
13964
13965    /// The wire type corresponding to [`NodeInfo`].
13966    #[repr(C)]
13967    pub struct NodeInfo<'de> {
13968        pub(crate) table: ::fidl_next::wire::Table<'de>,
13969    }
13970
13971    impl<'de> Drop for NodeInfo<'de> {
13972        fn drop(&mut self) {
13973            let _ = self.table.get(1).map(|envelope| unsafe {
13974                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
13975            });
13976        }
13977    }
13978
13979    impl ::fidl_next::Constrained for NodeInfo<'_> {
13980        type Constraint = ();
13981
13982        fn validate(
13983            _: ::fidl_next::Slot<'_, Self>,
13984            _: Self::Constraint,
13985        ) -> Result<(), ::fidl_next::ValidationError> {
13986            Ok(())
13987        }
13988    }
13989
13990    unsafe impl ::fidl_next::Wire for NodeInfo<'static> {
13991        type Narrowed<'de> = NodeInfo<'de>;
13992
13993        #[inline]
13994        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13995            ::fidl_next::munge!(let Self { table } = out);
13996            ::fidl_next::wire::Table::zero_padding(table);
13997        }
13998    }
13999
14000    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfo<'de>
14001    where
14002        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14003    {
14004        fn decode(
14005            slot: ::fidl_next::Slot<'_, Self>,
14006            decoder: &mut ___D,
14007            _: (),
14008        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14009            ::fidl_next::munge!(let Self { table } = slot);
14010
14011            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14012                match ordinal {
14013                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14014
14015                    1 => {
14016                        ::fidl_next::wire::Envelope::decode_as::<
14017                            ___D,
14018                            crate::wire::NodeAttributes2<'de>,
14019                        >(slot.as_mut(), decoder, ())?;
14020
14021                        Ok(())
14022                    }
14023
14024                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14025                }
14026            })
14027        }
14028    }
14029
14030    impl<'de> NodeInfo<'de> {
14031        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14032            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14033        }
14034
14035        pub fn take_attributes(
14036            &mut self,
14037        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14038            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14039        }
14040    }
14041
14042    impl<'de> ::core::fmt::Debug for NodeInfo<'de> {
14043        fn fmt(
14044            &self,
14045            f: &mut ::core::fmt::Formatter<'_>,
14046        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14047            f.debug_struct("NodeInfo").field("attributes", &self.attributes()).finish()
14048        }
14049    }
14050
14051    impl<'de> ::fidl_next::IntoNatural for NodeInfo<'de> {
14052        type Natural = crate::natural::NodeInfo;
14053    }
14054
14055    /// The wire type corresponding to [`DirectoryInfo`].
14056    #[repr(C)]
14057    pub struct DirectoryInfo<'de> {
14058        pub(crate) table: ::fidl_next::wire::Table<'de>,
14059    }
14060
14061    impl<'de> Drop for DirectoryInfo<'de> {
14062        fn drop(&mut self) {
14063            let _ = self.table.get(1).map(|envelope| unsafe {
14064                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
14065            });
14066        }
14067    }
14068
14069    impl ::fidl_next::Constrained for DirectoryInfo<'_> {
14070        type Constraint = ();
14071
14072        fn validate(
14073            _: ::fidl_next::Slot<'_, Self>,
14074            _: Self::Constraint,
14075        ) -> Result<(), ::fidl_next::ValidationError> {
14076            Ok(())
14077        }
14078    }
14079
14080    unsafe impl ::fidl_next::Wire for DirectoryInfo<'static> {
14081        type Narrowed<'de> = DirectoryInfo<'de>;
14082
14083        #[inline]
14084        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14085            ::fidl_next::munge!(let Self { table } = out);
14086            ::fidl_next::wire::Table::zero_padding(table);
14087        }
14088    }
14089
14090    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryInfo<'de>
14091    where
14092        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14093    {
14094        fn decode(
14095            slot: ::fidl_next::Slot<'_, Self>,
14096            decoder: &mut ___D,
14097            _: (),
14098        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14099            ::fidl_next::munge!(let Self { table } = slot);
14100
14101            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14102                match ordinal {
14103                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14104
14105                    1 => {
14106                        ::fidl_next::wire::Envelope::decode_as::<
14107                            ___D,
14108                            crate::wire::NodeAttributes2<'de>,
14109                        >(slot.as_mut(), decoder, ())?;
14110
14111                        Ok(())
14112                    }
14113
14114                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14115                }
14116            })
14117        }
14118    }
14119
14120    impl<'de> DirectoryInfo<'de> {
14121        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14122            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14123        }
14124
14125        pub fn take_attributes(
14126            &mut self,
14127        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14128            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14129        }
14130    }
14131
14132    impl<'de> ::core::fmt::Debug for DirectoryInfo<'de> {
14133        fn fmt(
14134            &self,
14135            f: &mut ::core::fmt::Formatter<'_>,
14136        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14137            f.debug_struct("DirectoryInfo").field("attributes", &self.attributes()).finish()
14138        }
14139    }
14140
14141    impl<'de> ::fidl_next::IntoNatural for DirectoryInfo<'de> {
14142        type Natural = crate::natural::DirectoryInfo;
14143    }
14144
14145    /// The wire type corresponding to [`SymlinkInfo`].
14146    #[repr(C)]
14147    pub struct SymlinkInfo<'de> {
14148        pub(crate) table: ::fidl_next::wire::Table<'de>,
14149    }
14150
14151    impl<'de> Drop for SymlinkInfo<'de> {
14152        fn drop(&mut self) {
14153            let _ = self.table.get(1).map(|envelope| unsafe {
14154                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
14155            });
14156
14157            let _ = self.table.get(2).map(|envelope| unsafe {
14158                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
14159            });
14160        }
14161    }
14162
14163    impl ::fidl_next::Constrained for SymlinkInfo<'_> {
14164        type Constraint = ();
14165
14166        fn validate(
14167            _: ::fidl_next::Slot<'_, Self>,
14168            _: Self::Constraint,
14169        ) -> Result<(), ::fidl_next::ValidationError> {
14170            Ok(())
14171        }
14172    }
14173
14174    unsafe impl ::fidl_next::Wire for SymlinkInfo<'static> {
14175        type Narrowed<'de> = SymlinkInfo<'de>;
14176
14177        #[inline]
14178        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14179            ::fidl_next::munge!(let Self { table } = out);
14180            ::fidl_next::wire::Table::zero_padding(table);
14181        }
14182    }
14183
14184    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkInfo<'de>
14185    where
14186        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14187    {
14188        fn decode(
14189            slot: ::fidl_next::Slot<'_, Self>,
14190            decoder: &mut ___D,
14191            _: (),
14192        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14193            ::fidl_next::munge!(let Self { table } = slot);
14194
14195            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14196                match ordinal {
14197                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14198
14199                    1 => {
14200                        ::fidl_next::wire::Envelope::decode_as::<
14201                            ___D,
14202                            ::fidl_next::wire::Vector<'de, u8>,
14203                        >(slot.as_mut(), decoder, (4095, ()))?;
14204
14205                        let value = unsafe {
14206                            slot.deref_unchecked()
14207                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
14208                        };
14209
14210                        if value.len() > 4095 {
14211                            return Err(::fidl_next::DecodeError::VectorTooLong {
14212                                size: value.len() as u64,
14213                                limit: 4095,
14214                            });
14215                        }
14216
14217                        Ok(())
14218                    }
14219
14220                    2 => {
14221                        ::fidl_next::wire::Envelope::decode_as::<
14222                            ___D,
14223                            crate::wire::NodeAttributes2<'de>,
14224                        >(slot.as_mut(), decoder, ())?;
14225
14226                        Ok(())
14227                    }
14228
14229                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14230                }
14231            })
14232        }
14233    }
14234
14235    impl<'de> SymlinkInfo<'de> {
14236        pub fn target(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
14237            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14238        }
14239
14240        pub fn take_target(
14241            &mut self,
14242        ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
14243            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14244        }
14245
14246        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14247            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14248        }
14249
14250        pub fn take_attributes(
14251            &mut self,
14252        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14253            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14254        }
14255    }
14256
14257    impl<'de> ::core::fmt::Debug for SymlinkInfo<'de> {
14258        fn fmt(
14259            &self,
14260            f: &mut ::core::fmt::Formatter<'_>,
14261        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14262            f.debug_struct("SymlinkInfo")
14263                .field("target", &self.target())
14264                .field("attributes", &self.attributes())
14265                .finish()
14266        }
14267    }
14268
14269    impl<'de> ::fidl_next::IntoNatural for SymlinkInfo<'de> {
14270        type Natural = crate::natural::SymlinkInfo;
14271    }
14272
14273    /// The wire type corresponding to [`NodeAttributesQuery`](crate::natural::NodeAttributesQuery).
14274    #[derive(Clone, Copy, Debug)]
14275    #[repr(transparent)]
14276    pub struct NodeAttributesQuery {
14277        pub(crate) value: ::fidl_next::wire::Uint64,
14278    }
14279
14280    impl ::fidl_next::Constrained for NodeAttributesQuery {
14281        type Constraint = ();
14282
14283        fn validate(
14284            _: ::fidl_next::Slot<'_, Self>,
14285            _: Self::Constraint,
14286        ) -> Result<(), ::fidl_next::ValidationError> {
14287            Ok(())
14288        }
14289    }
14290
14291    unsafe impl ::fidl_next::Wire for NodeAttributesQuery {
14292        type Narrowed<'de> = Self;
14293
14294        #[inline]
14295        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14296            // Wire bits have no padding
14297        }
14298    }
14299
14300    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributesQuery
14301    where
14302        ___D: ?Sized,
14303    {
14304        fn decode(
14305            slot: ::fidl_next::Slot<'_, Self>,
14306            _: &mut ___D,
14307            _: (),
14308        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14309            Ok(())
14310        }
14311    }
14312
14313    impl ::core::convert::From<crate::natural::NodeAttributesQuery> for NodeAttributesQuery {
14314        fn from(natural: crate::natural::NodeAttributesQuery) -> Self {
14315            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
14316        }
14317    }
14318
14319    impl ::fidl_next::IntoNatural for NodeAttributesQuery {
14320        type Natural = crate::natural::NodeAttributesQuery;
14321    }
14322
14323    /// The wire type corresponding to [`NodeGetAttributesRequest`].
14324    #[derive(Clone, Debug)]
14325    #[repr(C)]
14326    pub struct NodeGetAttributesRequest {
14327        pub query: crate::wire::NodeAttributesQuery,
14328    }
14329
14330    static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetAttributesRequest>(), 8);
14331    static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetAttributesRequest>(), 8);
14332
14333    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetAttributesRequest, query), 0);
14334
14335    impl ::fidl_next::Constrained for NodeGetAttributesRequest {
14336        type Constraint = ();
14337
14338        fn validate(
14339            _: ::fidl_next::Slot<'_, Self>,
14340            _: Self::Constraint,
14341        ) -> Result<(), ::fidl_next::ValidationError> {
14342            Ok(())
14343        }
14344    }
14345
14346    unsafe impl ::fidl_next::Wire for NodeGetAttributesRequest {
14347        type Narrowed<'de> = NodeGetAttributesRequest;
14348
14349        #[inline]
14350        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14351            ::fidl_next::munge! {
14352                let Self {
14353                    query,
14354
14355                } = &mut *out_;
14356            }
14357
14358            ::fidl_next::Wire::zero_padding(query);
14359        }
14360    }
14361
14362    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetAttributesRequest
14363    where
14364        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14365    {
14366        fn decode(
14367            slot_: ::fidl_next::Slot<'_, Self>,
14368            decoder_: &mut ___D,
14369            _: (),
14370        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14371            ::fidl_next::munge! {
14372                let Self {
14373                    mut query,
14374
14375                } = slot_;
14376            }
14377
14378            let _field = query.as_mut();
14379
14380            ::fidl_next::Decode::decode(query.as_mut(), decoder_, ())?;
14381
14382            Ok(())
14383        }
14384    }
14385
14386    impl ::fidl_next::IntoNatural for NodeGetAttributesRequest {
14387        type Natural = crate::natural::NodeGetAttributesRequest;
14388    }
14389
14390    /// The wire type corresponding to [`Options`].
14391    #[repr(C)]
14392    pub struct Options<'de> {
14393        pub(crate) table: ::fidl_next::wire::Table<'de>,
14394    }
14395
14396    impl<'de> Drop for Options<'de> {
14397        fn drop(&mut self) {
14398            let _ = self.table.get(1).map(|envelope| unsafe {
14399                envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
14400            });
14401
14402            let _ = self.table.get(2).map(|envelope| unsafe {
14403                envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
14404            });
14405        }
14406    }
14407
14408    impl ::fidl_next::Constrained for Options<'_> {
14409        type Constraint = ();
14410
14411        fn validate(
14412            _: ::fidl_next::Slot<'_, Self>,
14413            _: Self::Constraint,
14414        ) -> Result<(), ::fidl_next::ValidationError> {
14415            Ok(())
14416        }
14417    }
14418
14419    unsafe impl ::fidl_next::Wire for Options<'static> {
14420        type Narrowed<'de> = Options<'de>;
14421
14422        #[inline]
14423        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14424            ::fidl_next::munge!(let Self { table } = out);
14425            ::fidl_next::wire::Table::zero_padding(table);
14426        }
14427    }
14428
14429    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Options<'de>
14430    where
14431        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14432    {
14433        fn decode(
14434            slot: ::fidl_next::Slot<'_, Self>,
14435            decoder: &mut ___D,
14436            _: (),
14437        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14438            ::fidl_next::munge!(let Self { table } = slot);
14439
14440            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14441                match ordinal {
14442                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14443
14444                    1 => {
14445                        ::fidl_next::wire::Envelope::decode_as::<
14446                            ___D,
14447                            crate::wire::NodeAttributesQuery,
14448                        >(slot.as_mut(), decoder, ())?;
14449
14450                        Ok(())
14451                    }
14452
14453                    2 => {
14454                        ::fidl_next::wire::Envelope::decode_as::<
14455                            ___D,
14456                            crate::wire::MutableNodeAttributes<'de>,
14457                        >(slot.as_mut(), decoder, ())?;
14458
14459                        Ok(())
14460                    }
14461
14462                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14463                }
14464            })
14465        }
14466    }
14467
14468    impl<'de> Options<'de> {
14469        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributesQuery> {
14470            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14471        }
14472
14473        pub fn take_attributes(
14474            &mut self,
14475        ) -> ::core::option::Option<crate::wire::NodeAttributesQuery> {
14476            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14477        }
14478
14479        pub fn create_attributes(
14480            &self,
14481        ) -> ::core::option::Option<&crate::wire::MutableNodeAttributes<'de>> {
14482            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14483        }
14484
14485        pub fn take_create_attributes(
14486            &mut self,
14487        ) -> ::core::option::Option<crate::wire::MutableNodeAttributes<'de>> {
14488            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14489        }
14490    }
14491
14492    impl<'de> ::core::fmt::Debug for Options<'de> {
14493        fn fmt(
14494            &self,
14495            f: &mut ::core::fmt::Formatter<'_>,
14496        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14497            f.debug_struct("Options")
14498                .field("attributes", &self.attributes())
14499                .field("create_attributes", &self.create_attributes())
14500                .finish()
14501        }
14502    }
14503
14504    impl<'de> ::fidl_next::IntoNatural for Options<'de> {
14505        type Natural = crate::natural::Options;
14506    }
14507
14508    /// The wire type corresponding to [`DirectoryObject`].
14509    pub type DirectoryObject = ::fidl_next::wire::Unit;
14510
14511    /// The wire type corresponding to [`DirentType`].
14512    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
14513    #[repr(transparent)]
14514    pub struct DirentType {
14515        pub(crate) value: u8,
14516    }
14517
14518    impl ::fidl_next::Constrained for DirentType {
14519        type Constraint = ();
14520
14521        fn validate(
14522            _: ::fidl_next::Slot<'_, Self>,
14523            _: Self::Constraint,
14524        ) -> Result<(), ::fidl_next::ValidationError> {
14525            Ok(())
14526        }
14527    }
14528
14529    unsafe impl ::fidl_next::Wire for DirentType {
14530        type Narrowed<'de> = Self;
14531
14532        #[inline]
14533        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14534            // Wire enums have no padding
14535        }
14536    }
14537
14538    impl DirentType {
14539        pub const UNKNOWN: DirentType = DirentType { value: 0 };
14540
14541        pub const DIRECTORY: DirentType = DirentType { value: 4 };
14542
14543        pub const BLOCK_DEVICE: DirentType = DirentType { value: 6 };
14544
14545        pub const FILE: DirentType = DirentType { value: 8 };
14546
14547        pub const SYMLINK: DirentType = DirentType { value: 10 };
14548
14549        pub const SERVICE: DirentType = DirentType { value: 16 };
14550    }
14551
14552    unsafe impl<___D> ::fidl_next::Decode<___D> for DirentType
14553    where
14554        ___D: ?Sized,
14555    {
14556        fn decode(
14557            slot: ::fidl_next::Slot<'_, Self>,
14558            _: &mut ___D,
14559            _: (),
14560        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14561            Ok(())
14562        }
14563    }
14564
14565    impl ::core::convert::From<crate::natural::DirentType> for DirentType {
14566        fn from(natural: crate::natural::DirentType) -> Self {
14567            match natural {
14568                crate::natural::DirentType::Unknown => DirentType::UNKNOWN,
14569
14570                crate::natural::DirentType::Directory => DirentType::DIRECTORY,
14571
14572                crate::natural::DirentType::BlockDevice => DirentType::BLOCK_DEVICE,
14573
14574                crate::natural::DirentType::File => DirentType::FILE,
14575
14576                crate::natural::DirentType::Symlink => DirentType::SYMLINK,
14577
14578                crate::natural::DirentType::Service => DirentType::SERVICE,
14579
14580                crate::natural::DirentType::UnknownOrdinal_(value) => {
14581                    DirentType { value: u8::from(value) }
14582                }
14583            }
14584        }
14585    }
14586
14587    impl ::fidl_next::IntoNatural for DirentType {
14588        type Natural = crate::natural::DirentType;
14589    }
14590
14591    /// The wire type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
14592    #[derive(Debug)]
14593    #[repr(C)]
14594    pub struct ExtendedAttributeIteratorGetNextResponse<'de> {
14595        pub attributes: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Vector<'de, u8>>,
14596
14597        pub last: bool,
14598    }
14599
14600    static_assertions::const_assert_eq!(
14601        std::mem::size_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
14602        24
14603    );
14604    static_assertions::const_assert_eq!(
14605        std::mem::align_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
14606        8
14607    );
14608
14609    static_assertions::const_assert_eq!(
14610        std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, attributes),
14611        0
14612    );
14613
14614    static_assertions::const_assert_eq!(
14615        std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, last),
14616        16
14617    );
14618
14619    impl ::fidl_next::Constrained for ExtendedAttributeIteratorGetNextResponse<'_> {
14620        type Constraint = ();
14621
14622        fn validate(
14623            _: ::fidl_next::Slot<'_, Self>,
14624            _: Self::Constraint,
14625        ) -> Result<(), ::fidl_next::ValidationError> {
14626            Ok(())
14627        }
14628    }
14629
14630    unsafe impl ::fidl_next::Wire for ExtendedAttributeIteratorGetNextResponse<'static> {
14631        type Narrowed<'de> = ExtendedAttributeIteratorGetNextResponse<'de>;
14632
14633        #[inline]
14634        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14635            ::fidl_next::munge! {
14636                let Self {
14637                    attributes,
14638                    last,
14639
14640                } = &mut *out_;
14641            }
14642
14643            ::fidl_next::Wire::zero_padding(attributes);
14644
14645            ::fidl_next::Wire::zero_padding(last);
14646
14647            unsafe {
14648                out_.as_mut_ptr().cast::<u8>().add(17).write_bytes(0, 7);
14649            }
14650        }
14651    }
14652
14653    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeIteratorGetNextResponse<'de>
14654    where
14655        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14656        ___D: ::fidl_next::Decoder<'de>,
14657    {
14658        fn decode(
14659            slot_: ::fidl_next::Slot<'_, Self>,
14660            decoder_: &mut ___D,
14661            _: (),
14662        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14663            if slot_.as_bytes()[17..24] != [0u8; 7] {
14664                return Err(::fidl_next::DecodeError::InvalidPadding);
14665            }
14666
14667            ::fidl_next::munge! {
14668                let Self {
14669                    mut attributes,
14670                    mut last,
14671
14672                } = slot_;
14673            }
14674
14675            let _field = attributes.as_mut();
14676            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
14677            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, (128, (255, ())))?;
14678
14679            let attributes = unsafe { attributes.deref_unchecked() };
14680
14681            if attributes.len() > 128 {
14682                return Err(::fidl_next::DecodeError::VectorTooLong {
14683                    size: attributes.len() as u64,
14684                    limit: 128,
14685                });
14686            }
14687
14688            let _field = last.as_mut();
14689
14690            ::fidl_next::Decode::decode(last.as_mut(), decoder_, ())?;
14691
14692            Ok(())
14693        }
14694    }
14695
14696    impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeIteratorGetNextResponse<'de> {
14697        type Natural = crate::natural::ExtendedAttributeIteratorGetNextResponse;
14698    }
14699
14700    /// The wire type corresponding to [`ReadableReadRequest`].
14701    #[derive(Clone, Debug)]
14702    #[repr(C)]
14703    pub struct ReadableReadRequest {
14704        pub count: ::fidl_next::wire::Uint64,
14705    }
14706
14707    static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadRequest>(), 8);
14708    static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadRequest>(), 8);
14709
14710    static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadRequest, count), 0);
14711
14712    impl ::fidl_next::Constrained for ReadableReadRequest {
14713        type Constraint = ();
14714
14715        fn validate(
14716            _: ::fidl_next::Slot<'_, Self>,
14717            _: Self::Constraint,
14718        ) -> Result<(), ::fidl_next::ValidationError> {
14719            Ok(())
14720        }
14721    }
14722
14723    unsafe impl ::fidl_next::Wire for ReadableReadRequest {
14724        type Narrowed<'de> = ReadableReadRequest;
14725
14726        #[inline]
14727        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14728            ::fidl_next::munge! {
14729                let Self {
14730                    count,
14731
14732                } = &mut *out_;
14733            }
14734
14735            ::fidl_next::Wire::zero_padding(count);
14736        }
14737    }
14738
14739    unsafe impl<___D> ::fidl_next::Decode<___D> for ReadableReadRequest
14740    where
14741        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14742    {
14743        fn decode(
14744            slot_: ::fidl_next::Slot<'_, Self>,
14745            decoder_: &mut ___D,
14746            _: (),
14747        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14748            ::fidl_next::munge! {
14749                let Self {
14750                    mut count,
14751
14752                } = slot_;
14753            }
14754
14755            let _field = count.as_mut();
14756
14757            ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
14758
14759            Ok(())
14760        }
14761    }
14762
14763    impl ::fidl_next::IntoNatural for ReadableReadRequest {
14764        type Natural = crate::natural::ReadableReadRequest;
14765    }
14766
14767    /// The wire type corresponding to [`Transfer`](crate::natural::Transfer).
14768    pub type Transfer<'de> = ::fidl_next::wire::Vector<'de, u8>;
14769
14770    /// The wire type corresponding to [`ReadableReadResponse`].
14771    #[derive(Debug)]
14772    #[repr(C)]
14773    pub struct ReadableReadResponse<'de> {
14774        pub data: ::fidl_next::wire::Vector<'de, u8>,
14775    }
14776
14777    static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadResponse<'_>>(), 16);
14778    static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadResponse<'_>>(), 8);
14779
14780    static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadResponse<'_>, data), 0);
14781
14782    impl ::fidl_next::Constrained for ReadableReadResponse<'_> {
14783        type Constraint = ();
14784
14785        fn validate(
14786            _: ::fidl_next::Slot<'_, Self>,
14787            _: Self::Constraint,
14788        ) -> Result<(), ::fidl_next::ValidationError> {
14789            Ok(())
14790        }
14791    }
14792
14793    unsafe impl ::fidl_next::Wire for ReadableReadResponse<'static> {
14794        type Narrowed<'de> = ReadableReadResponse<'de>;
14795
14796        #[inline]
14797        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14798            ::fidl_next::munge! {
14799                let Self {
14800                    data,
14801
14802                } = &mut *out_;
14803            }
14804
14805            ::fidl_next::Wire::zero_padding(data);
14806        }
14807    }
14808
14809    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ReadableReadResponse<'de>
14810    where
14811        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14812        ___D: ::fidl_next::Decoder<'de>,
14813    {
14814        fn decode(
14815            slot_: ::fidl_next::Slot<'_, Self>,
14816            decoder_: &mut ___D,
14817            _: (),
14818        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14819            ::fidl_next::munge! {
14820                let Self {
14821                    mut data,
14822
14823                } = slot_;
14824            }
14825
14826            let _field = data.as_mut();
14827            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
14828            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
14829
14830            let data = unsafe { data.deref_unchecked() };
14831
14832            if data.len() > 8192 {
14833                return Err(::fidl_next::DecodeError::VectorTooLong {
14834                    size: data.len() as u64,
14835                    limit: 8192,
14836                });
14837            }
14838
14839            Ok(())
14840        }
14841    }
14842
14843    impl<'de> ::fidl_next::IntoNatural for ReadableReadResponse<'de> {
14844        type Natural = crate::natural::ReadableReadResponse;
14845    }
14846
14847    /// The wire type corresponding to [`WritableWriteRequest`].
14848    #[derive(Debug)]
14849    #[repr(C)]
14850    pub struct WritableWriteRequest<'de> {
14851        pub data: ::fidl_next::wire::Vector<'de, u8>,
14852    }
14853
14854    static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteRequest<'_>>(), 16);
14855    static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteRequest<'_>>(), 8);
14856
14857    static_assertions::const_assert_eq!(std::mem::offset_of!(WritableWriteRequest<'_>, data), 0);
14858
14859    impl ::fidl_next::Constrained for WritableWriteRequest<'_> {
14860        type Constraint = ();
14861
14862        fn validate(
14863            _: ::fidl_next::Slot<'_, Self>,
14864            _: Self::Constraint,
14865        ) -> Result<(), ::fidl_next::ValidationError> {
14866            Ok(())
14867        }
14868    }
14869
14870    unsafe impl ::fidl_next::Wire for WritableWriteRequest<'static> {
14871        type Narrowed<'de> = WritableWriteRequest<'de>;
14872
14873        #[inline]
14874        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14875            ::fidl_next::munge! {
14876                let Self {
14877                    data,
14878
14879                } = &mut *out_;
14880            }
14881
14882            ::fidl_next::Wire::zero_padding(data);
14883        }
14884    }
14885
14886    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for WritableWriteRequest<'de>
14887    where
14888        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14889        ___D: ::fidl_next::Decoder<'de>,
14890    {
14891        fn decode(
14892            slot_: ::fidl_next::Slot<'_, Self>,
14893            decoder_: &mut ___D,
14894            _: (),
14895        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14896            ::fidl_next::munge! {
14897                let Self {
14898                    mut data,
14899
14900                } = slot_;
14901            }
14902
14903            let _field = data.as_mut();
14904            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
14905            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
14906
14907            let data = unsafe { data.deref_unchecked() };
14908
14909            if data.len() > 8192 {
14910                return Err(::fidl_next::DecodeError::VectorTooLong {
14911                    size: data.len() as u64,
14912                    limit: 8192,
14913                });
14914            }
14915
14916            Ok(())
14917        }
14918    }
14919
14920    impl<'de> ::fidl_next::IntoNatural for WritableWriteRequest<'de> {
14921        type Natural = crate::natural::WritableWriteRequest;
14922    }
14923
14924    /// The wire type corresponding to [`WritableWriteResponse`].
14925    #[derive(Clone, Debug)]
14926    #[repr(C)]
14927    pub struct WritableWriteResponse {
14928        pub actual_count: ::fidl_next::wire::Uint64,
14929    }
14930
14931    static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteResponse>(), 8);
14932    static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteResponse>(), 8);
14933
14934    static_assertions::const_assert_eq!(
14935        std::mem::offset_of!(WritableWriteResponse, actual_count),
14936        0
14937    );
14938
14939    impl ::fidl_next::Constrained for WritableWriteResponse {
14940        type Constraint = ();
14941
14942        fn validate(
14943            _: ::fidl_next::Slot<'_, Self>,
14944            _: Self::Constraint,
14945        ) -> Result<(), ::fidl_next::ValidationError> {
14946            Ok(())
14947        }
14948    }
14949
14950    unsafe impl ::fidl_next::Wire for WritableWriteResponse {
14951        type Narrowed<'de> = WritableWriteResponse;
14952
14953        #[inline]
14954        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14955            ::fidl_next::munge! {
14956                let Self {
14957                    actual_count,
14958
14959                } = &mut *out_;
14960            }
14961
14962            ::fidl_next::Wire::zero_padding(actual_count);
14963        }
14964    }
14965
14966    unsafe impl<___D> ::fidl_next::Decode<___D> for WritableWriteResponse
14967    where
14968        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14969    {
14970        fn decode(
14971            slot_: ::fidl_next::Slot<'_, Self>,
14972            decoder_: &mut ___D,
14973            _: (),
14974        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14975            ::fidl_next::munge! {
14976                let Self {
14977                    mut actual_count,
14978
14979                } = slot_;
14980            }
14981
14982            let _field = actual_count.as_mut();
14983
14984            ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
14985
14986            Ok(())
14987        }
14988    }
14989
14990    impl ::fidl_next::IntoNatural for WritableWriteResponse {
14991        type Natural = crate::natural::WritableWriteResponse;
14992    }
14993
14994    /// The wire type corresponding to [`FileSeekRequest`].
14995    #[derive(Clone, Debug)]
14996    #[repr(C)]
14997    pub struct FileSeekRequest {
14998        pub origin: crate::wire::SeekOrigin,
14999
15000        pub offset: ::fidl_next::wire::Int64,
15001    }
15002
15003    static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekRequest>(), 16);
15004    static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekRequest>(), 8);
15005
15006    static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, origin), 0);
15007
15008    static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, offset), 8);
15009
15010    impl ::fidl_next::Constrained for FileSeekRequest {
15011        type Constraint = ();
15012
15013        fn validate(
15014            _: ::fidl_next::Slot<'_, Self>,
15015            _: Self::Constraint,
15016        ) -> Result<(), ::fidl_next::ValidationError> {
15017            Ok(())
15018        }
15019    }
15020
15021    unsafe impl ::fidl_next::Wire for FileSeekRequest {
15022        type Narrowed<'de> = FileSeekRequest;
15023
15024        #[inline]
15025        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15026            ::fidl_next::munge! {
15027                let Self {
15028                    origin,
15029                    offset,
15030
15031                } = &mut *out_;
15032            }
15033
15034            ::fidl_next::Wire::zero_padding(origin);
15035
15036            ::fidl_next::Wire::zero_padding(offset);
15037
15038            unsafe {
15039                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
15040            }
15041        }
15042    }
15043
15044    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekRequest
15045    where
15046        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15047    {
15048        fn decode(
15049            slot_: ::fidl_next::Slot<'_, Self>,
15050            decoder_: &mut ___D,
15051            _: (),
15052        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15053            if slot_.as_bytes()[4..8] != [0u8; 4] {
15054                return Err(::fidl_next::DecodeError::InvalidPadding);
15055            }
15056
15057            ::fidl_next::munge! {
15058                let Self {
15059                    mut origin,
15060                    mut offset,
15061
15062                } = slot_;
15063            }
15064
15065            let _field = origin.as_mut();
15066
15067            ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
15068
15069            let _field = offset.as_mut();
15070
15071            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15072
15073            Ok(())
15074        }
15075    }
15076
15077    impl ::fidl_next::IntoNatural for FileSeekRequest {
15078        type Natural = crate::natural::FileSeekRequest;
15079    }
15080
15081    /// The wire type corresponding to [`FileSeekResponse`].
15082    #[derive(Clone, Debug)]
15083    #[repr(C)]
15084    pub struct FileSeekResponse {
15085        pub offset_from_start: ::fidl_next::wire::Uint64,
15086    }
15087
15088    static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekResponse>(), 8);
15089    static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekResponse>(), 8);
15090
15091    static_assertions::const_assert_eq!(
15092        std::mem::offset_of!(FileSeekResponse, offset_from_start),
15093        0
15094    );
15095
15096    impl ::fidl_next::Constrained for FileSeekResponse {
15097        type Constraint = ();
15098
15099        fn validate(
15100            _: ::fidl_next::Slot<'_, Self>,
15101            _: Self::Constraint,
15102        ) -> Result<(), ::fidl_next::ValidationError> {
15103            Ok(())
15104        }
15105    }
15106
15107    unsafe impl ::fidl_next::Wire for FileSeekResponse {
15108        type Narrowed<'de> = FileSeekResponse;
15109
15110        #[inline]
15111        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15112            ::fidl_next::munge! {
15113                let Self {
15114                    offset_from_start,
15115
15116                } = &mut *out_;
15117            }
15118
15119            ::fidl_next::Wire::zero_padding(offset_from_start);
15120        }
15121    }
15122
15123    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekResponse
15124    where
15125        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15126    {
15127        fn decode(
15128            slot_: ::fidl_next::Slot<'_, Self>,
15129            decoder_: &mut ___D,
15130            _: (),
15131        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15132            ::fidl_next::munge! {
15133                let Self {
15134                    mut offset_from_start,
15135
15136                } = slot_;
15137            }
15138
15139            let _field = offset_from_start.as_mut();
15140
15141            ::fidl_next::Decode::decode(offset_from_start.as_mut(), decoder_, ())?;
15142
15143            Ok(())
15144        }
15145    }
15146
15147    impl ::fidl_next::IntoNatural for FileSeekResponse {
15148        type Natural = crate::natural::FileSeekResponse;
15149    }
15150
15151    /// The wire type corresponding to [`FileReadAtRequest`].
15152    #[derive(Clone, Debug)]
15153    #[repr(C)]
15154    pub struct FileReadAtRequest {
15155        pub count: ::fidl_next::wire::Uint64,
15156
15157        pub offset: ::fidl_next::wire::Uint64,
15158    }
15159
15160    static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtRequest>(), 16);
15161    static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtRequest>(), 8);
15162
15163    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, count), 0);
15164
15165    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, offset), 8);
15166
15167    impl ::fidl_next::Constrained for FileReadAtRequest {
15168        type Constraint = ();
15169
15170        fn validate(
15171            _: ::fidl_next::Slot<'_, Self>,
15172            _: Self::Constraint,
15173        ) -> Result<(), ::fidl_next::ValidationError> {
15174            Ok(())
15175        }
15176    }
15177
15178    unsafe impl ::fidl_next::Wire for FileReadAtRequest {
15179        type Narrowed<'de> = FileReadAtRequest;
15180
15181        #[inline]
15182        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15183            ::fidl_next::munge! {
15184                let Self {
15185                    count,
15186                    offset,
15187
15188                } = &mut *out_;
15189            }
15190
15191            ::fidl_next::Wire::zero_padding(count);
15192
15193            ::fidl_next::Wire::zero_padding(offset);
15194        }
15195    }
15196
15197    unsafe impl<___D> ::fidl_next::Decode<___D> for FileReadAtRequest
15198    where
15199        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15200    {
15201        fn decode(
15202            slot_: ::fidl_next::Slot<'_, Self>,
15203            decoder_: &mut ___D,
15204            _: (),
15205        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15206            ::fidl_next::munge! {
15207                let Self {
15208                    mut count,
15209                    mut offset,
15210
15211                } = slot_;
15212            }
15213
15214            let _field = count.as_mut();
15215
15216            ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
15217
15218            let _field = offset.as_mut();
15219
15220            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15221
15222            Ok(())
15223        }
15224    }
15225
15226    impl ::fidl_next::IntoNatural for FileReadAtRequest {
15227        type Natural = crate::natural::FileReadAtRequest;
15228    }
15229
15230    /// The wire type corresponding to [`FileReadAtResponse`].
15231    #[derive(Debug)]
15232    #[repr(C)]
15233    pub struct FileReadAtResponse<'de> {
15234        pub data: ::fidl_next::wire::Vector<'de, u8>,
15235    }
15236
15237    static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtResponse<'_>>(), 16);
15238    static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtResponse<'_>>(), 8);
15239
15240    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtResponse<'_>, data), 0);
15241
15242    impl ::fidl_next::Constrained for FileReadAtResponse<'_> {
15243        type Constraint = ();
15244
15245        fn validate(
15246            _: ::fidl_next::Slot<'_, Self>,
15247            _: Self::Constraint,
15248        ) -> Result<(), ::fidl_next::ValidationError> {
15249            Ok(())
15250        }
15251    }
15252
15253    unsafe impl ::fidl_next::Wire for FileReadAtResponse<'static> {
15254        type Narrowed<'de> = FileReadAtResponse<'de>;
15255
15256        #[inline]
15257        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15258            ::fidl_next::munge! {
15259                let Self {
15260                    data,
15261
15262                } = &mut *out_;
15263            }
15264
15265            ::fidl_next::Wire::zero_padding(data);
15266        }
15267    }
15268
15269    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileReadAtResponse<'de>
15270    where
15271        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15272        ___D: ::fidl_next::Decoder<'de>,
15273    {
15274        fn decode(
15275            slot_: ::fidl_next::Slot<'_, Self>,
15276            decoder_: &mut ___D,
15277            _: (),
15278        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15279            ::fidl_next::munge! {
15280                let Self {
15281                    mut data,
15282
15283                } = slot_;
15284            }
15285
15286            let _field = data.as_mut();
15287            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
15288            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
15289
15290            let data = unsafe { data.deref_unchecked() };
15291
15292            if data.len() > 8192 {
15293                return Err(::fidl_next::DecodeError::VectorTooLong {
15294                    size: data.len() as u64,
15295                    limit: 8192,
15296                });
15297            }
15298
15299            Ok(())
15300        }
15301    }
15302
15303    impl<'de> ::fidl_next::IntoNatural for FileReadAtResponse<'de> {
15304        type Natural = crate::natural::FileReadAtResponse;
15305    }
15306
15307    /// The wire type corresponding to [`FileWriteAtRequest`].
15308    #[derive(Debug)]
15309    #[repr(C)]
15310    pub struct FileWriteAtRequest<'de> {
15311        pub data: ::fidl_next::wire::Vector<'de, u8>,
15312
15313        pub offset: ::fidl_next::wire::Uint64,
15314    }
15315
15316    static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtRequest<'_>>(), 24);
15317    static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtRequest<'_>>(), 8);
15318
15319    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, data), 0);
15320
15321    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, offset), 16);
15322
15323    impl ::fidl_next::Constrained for FileWriteAtRequest<'_> {
15324        type Constraint = ();
15325
15326        fn validate(
15327            _: ::fidl_next::Slot<'_, Self>,
15328            _: Self::Constraint,
15329        ) -> Result<(), ::fidl_next::ValidationError> {
15330            Ok(())
15331        }
15332    }
15333
15334    unsafe impl ::fidl_next::Wire for FileWriteAtRequest<'static> {
15335        type Narrowed<'de> = FileWriteAtRequest<'de>;
15336
15337        #[inline]
15338        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15339            ::fidl_next::munge! {
15340                let Self {
15341                    data,
15342                    offset,
15343
15344                } = &mut *out_;
15345            }
15346
15347            ::fidl_next::Wire::zero_padding(data);
15348
15349            ::fidl_next::Wire::zero_padding(offset);
15350        }
15351    }
15352
15353    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileWriteAtRequest<'de>
15354    where
15355        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15356        ___D: ::fidl_next::Decoder<'de>,
15357    {
15358        fn decode(
15359            slot_: ::fidl_next::Slot<'_, Self>,
15360            decoder_: &mut ___D,
15361            _: (),
15362        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15363            ::fidl_next::munge! {
15364                let Self {
15365                    mut data,
15366                    mut offset,
15367
15368                } = slot_;
15369            }
15370
15371            let _field = data.as_mut();
15372            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
15373            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
15374
15375            let data = unsafe { data.deref_unchecked() };
15376
15377            if data.len() > 8192 {
15378                return Err(::fidl_next::DecodeError::VectorTooLong {
15379                    size: data.len() as u64,
15380                    limit: 8192,
15381                });
15382            }
15383
15384            let _field = offset.as_mut();
15385
15386            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15387
15388            Ok(())
15389        }
15390    }
15391
15392    impl<'de> ::fidl_next::IntoNatural for FileWriteAtRequest<'de> {
15393        type Natural = crate::natural::FileWriteAtRequest;
15394    }
15395
15396    /// The wire type corresponding to [`FileWriteAtResponse`].
15397    #[derive(Clone, Debug)]
15398    #[repr(C)]
15399    pub struct FileWriteAtResponse {
15400        pub actual_count: ::fidl_next::wire::Uint64,
15401    }
15402
15403    static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtResponse>(), 8);
15404    static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtResponse>(), 8);
15405
15406    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtResponse, actual_count), 0);
15407
15408    impl ::fidl_next::Constrained for FileWriteAtResponse {
15409        type Constraint = ();
15410
15411        fn validate(
15412            _: ::fidl_next::Slot<'_, Self>,
15413            _: Self::Constraint,
15414        ) -> Result<(), ::fidl_next::ValidationError> {
15415            Ok(())
15416        }
15417    }
15418
15419    unsafe impl ::fidl_next::Wire for FileWriteAtResponse {
15420        type Narrowed<'de> = FileWriteAtResponse;
15421
15422        #[inline]
15423        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15424            ::fidl_next::munge! {
15425                let Self {
15426                    actual_count,
15427
15428                } = &mut *out_;
15429            }
15430
15431            ::fidl_next::Wire::zero_padding(actual_count);
15432        }
15433    }
15434
15435    unsafe impl<___D> ::fidl_next::Decode<___D> for FileWriteAtResponse
15436    where
15437        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15438    {
15439        fn decode(
15440            slot_: ::fidl_next::Slot<'_, Self>,
15441            decoder_: &mut ___D,
15442            _: (),
15443        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15444            ::fidl_next::munge! {
15445                let Self {
15446                    mut actual_count,
15447
15448                } = slot_;
15449            }
15450
15451            let _field = actual_count.as_mut();
15452
15453            ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
15454
15455            Ok(())
15456        }
15457    }
15458
15459    impl ::fidl_next::IntoNatural for FileWriteAtResponse {
15460        type Natural = crate::natural::FileWriteAtResponse;
15461    }
15462
15463    /// The wire type corresponding to [`FileResizeRequest`].
15464    #[derive(Clone, Debug)]
15465    #[repr(C)]
15466    pub struct FileResizeRequest {
15467        pub length: ::fidl_next::wire::Uint64,
15468    }
15469
15470    static_assertions::const_assert_eq!(std::mem::size_of::<FileResizeRequest>(), 8);
15471    static_assertions::const_assert_eq!(std::mem::align_of::<FileResizeRequest>(), 8);
15472
15473    static_assertions::const_assert_eq!(std::mem::offset_of!(FileResizeRequest, length), 0);
15474
15475    impl ::fidl_next::Constrained for FileResizeRequest {
15476        type Constraint = ();
15477
15478        fn validate(
15479            _: ::fidl_next::Slot<'_, Self>,
15480            _: Self::Constraint,
15481        ) -> Result<(), ::fidl_next::ValidationError> {
15482            Ok(())
15483        }
15484    }
15485
15486    unsafe impl ::fidl_next::Wire for FileResizeRequest {
15487        type Narrowed<'de> = FileResizeRequest;
15488
15489        #[inline]
15490        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15491            ::fidl_next::munge! {
15492                let Self {
15493                    length,
15494
15495                } = &mut *out_;
15496            }
15497
15498            ::fidl_next::Wire::zero_padding(length);
15499        }
15500    }
15501
15502    unsafe impl<___D> ::fidl_next::Decode<___D> for FileResizeRequest
15503    where
15504        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15505    {
15506        fn decode(
15507            slot_: ::fidl_next::Slot<'_, Self>,
15508            decoder_: &mut ___D,
15509            _: (),
15510        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15511            ::fidl_next::munge! {
15512                let Self {
15513                    mut length,
15514
15515                } = slot_;
15516            }
15517
15518            let _field = length.as_mut();
15519
15520            ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
15521
15522            Ok(())
15523        }
15524    }
15525
15526    impl ::fidl_next::IntoNatural for FileResizeRequest {
15527        type Natural = crate::natural::FileResizeRequest;
15528    }
15529
15530    /// The wire type corresponding to [`FileResizeResponse`].
15531    pub type FileResizeResponse = ::fidl_next::wire::Unit;
15532
15533    /// The wire type corresponding to [`VmoFlags`](crate::natural::VmoFlags).
15534    #[derive(Clone, Copy, Debug)]
15535    #[repr(transparent)]
15536    pub struct VmoFlags {
15537        pub(crate) value: ::fidl_next::wire::Uint32,
15538    }
15539
15540    impl ::fidl_next::Constrained for VmoFlags {
15541        type Constraint = ();
15542
15543        fn validate(
15544            _: ::fidl_next::Slot<'_, Self>,
15545            _: Self::Constraint,
15546        ) -> Result<(), ::fidl_next::ValidationError> {
15547            Ok(())
15548        }
15549    }
15550
15551    unsafe impl ::fidl_next::Wire for VmoFlags {
15552        type Narrowed<'de> = Self;
15553
15554        #[inline]
15555        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
15556            // Wire bits have no padding
15557        }
15558    }
15559
15560    unsafe impl<___D> ::fidl_next::Decode<___D> for VmoFlags
15561    where
15562        ___D: ?Sized,
15563    {
15564        fn decode(
15565            slot: ::fidl_next::Slot<'_, Self>,
15566            _: &mut ___D,
15567            _: (),
15568        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15569            ::fidl_next::munge!(let Self { value } = slot);
15570            let set = u32::from(*value);
15571            if set & !crate::natural::VmoFlags::all().bits() != 0 {
15572                return Err(::fidl_next::DecodeError::InvalidBits {
15573                    expected: crate::natural::VmoFlags::all().bits() as usize,
15574                    actual: set as usize,
15575                });
15576            }
15577
15578            Ok(())
15579        }
15580    }
15581
15582    impl ::core::convert::From<crate::natural::VmoFlags> for VmoFlags {
15583        fn from(natural: crate::natural::VmoFlags) -> Self {
15584            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
15585        }
15586    }
15587
15588    impl ::fidl_next::IntoNatural for VmoFlags {
15589        type Natural = crate::natural::VmoFlags;
15590    }
15591
15592    /// The wire type corresponding to [`FileGetBackingMemoryRequest`].
15593    #[derive(Clone, Debug)]
15594    #[repr(C)]
15595    pub struct FileGetBackingMemoryRequest {
15596        pub flags: crate::wire::VmoFlags,
15597    }
15598
15599    static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryRequest>(), 4);
15600    static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryRequest>(), 4);
15601
15602    static_assertions::const_assert_eq!(
15603        std::mem::offset_of!(FileGetBackingMemoryRequest, flags),
15604        0
15605    );
15606
15607    impl ::fidl_next::Constrained for FileGetBackingMemoryRequest {
15608        type Constraint = ();
15609
15610        fn validate(
15611            _: ::fidl_next::Slot<'_, Self>,
15612            _: Self::Constraint,
15613        ) -> Result<(), ::fidl_next::ValidationError> {
15614            Ok(())
15615        }
15616    }
15617
15618    unsafe impl ::fidl_next::Wire for FileGetBackingMemoryRequest {
15619        type Narrowed<'de> = FileGetBackingMemoryRequest;
15620
15621        #[inline]
15622        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15623            ::fidl_next::munge! {
15624                let Self {
15625                    flags,
15626
15627                } = &mut *out_;
15628            }
15629
15630            ::fidl_next::Wire::zero_padding(flags);
15631        }
15632    }
15633
15634    unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryRequest
15635    where
15636        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15637    {
15638        fn decode(
15639            slot_: ::fidl_next::Slot<'_, Self>,
15640            decoder_: &mut ___D,
15641            _: (),
15642        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15643            ::fidl_next::munge! {
15644                let Self {
15645                    mut flags,
15646
15647                } = slot_;
15648            }
15649
15650            let _field = flags.as_mut();
15651
15652            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15653
15654            Ok(())
15655        }
15656    }
15657
15658    impl ::fidl_next::IntoNatural for FileGetBackingMemoryRequest {
15659        type Natural = crate::natural::FileGetBackingMemoryRequest;
15660    }
15661
15662    /// The wire type corresponding to [`LinkableLinkIntoResponse`].
15663    pub type LinkableLinkIntoResponse = ::fidl_next::wire::Unit;
15664
15665    /// The wire type corresponding to [`FileAllocateResponse`].
15666    pub type FileAllocateResponse = ::fidl_next::wire::Unit;
15667
15668    /// The wire type corresponding to [`FileEnableVerityResponse`].
15669    pub type FileEnableVerityResponse = ::fidl_next::wire::Unit;
15670
15671    /// The wire type corresponding to [`FileSignal`](crate::natural::FileSignal).
15672    #[derive(Clone, Copy, Debug)]
15673    #[repr(transparent)]
15674    pub struct FileSignal {
15675        pub(crate) value: ::fidl_next::wire::Uint32,
15676    }
15677
15678    impl ::fidl_next::Constrained for FileSignal {
15679        type Constraint = ();
15680
15681        fn validate(
15682            _: ::fidl_next::Slot<'_, Self>,
15683            _: Self::Constraint,
15684        ) -> Result<(), ::fidl_next::ValidationError> {
15685            Ok(())
15686        }
15687    }
15688
15689    unsafe impl ::fidl_next::Wire for FileSignal {
15690        type Narrowed<'de> = Self;
15691
15692        #[inline]
15693        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
15694            // Wire bits have no padding
15695        }
15696    }
15697
15698    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSignal
15699    where
15700        ___D: ?Sized,
15701    {
15702        fn decode(
15703            slot: ::fidl_next::Slot<'_, Self>,
15704            _: &mut ___D,
15705            _: (),
15706        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15707            ::fidl_next::munge!(let Self { value } = slot);
15708            let set = u32::from(*value);
15709            if set & !crate::natural::FileSignal::all().bits() != 0 {
15710                return Err(::fidl_next::DecodeError::InvalidBits {
15711                    expected: crate::natural::FileSignal::all().bits() as usize,
15712                    actual: set as usize,
15713                });
15714            }
15715
15716            Ok(())
15717        }
15718    }
15719
15720    impl ::core::convert::From<crate::natural::FileSignal> for FileSignal {
15721        fn from(natural: crate::natural::FileSignal) -> Self {
15722            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
15723        }
15724    }
15725
15726    impl ::fidl_next::IntoNatural for FileSignal {
15727        type Natural = crate::natural::FileSignal;
15728    }
15729
15730    /// The wire type corresponding to [`FilesystemInfo`].
15731    #[derive(Clone, Debug)]
15732    #[repr(C)]
15733    pub struct FilesystemInfo {
15734        pub total_bytes: ::fidl_next::wire::Uint64,
15735
15736        pub used_bytes: ::fidl_next::wire::Uint64,
15737
15738        pub total_nodes: ::fidl_next::wire::Uint64,
15739
15740        pub used_nodes: ::fidl_next::wire::Uint64,
15741
15742        pub free_shared_pool_bytes: ::fidl_next::wire::Uint64,
15743
15744        pub fs_id: ::fidl_next::wire::Uint64,
15745
15746        pub block_size: ::fidl_next::wire::Uint32,
15747
15748        pub max_filename_size: ::fidl_next::wire::Uint32,
15749
15750        pub fs_type: ::fidl_next::wire::Uint32,
15751
15752        pub padding: ::fidl_next::wire::Uint32,
15753
15754        pub name: [i8; 32],
15755    }
15756
15757    static_assertions::const_assert_eq!(std::mem::size_of::<FilesystemInfo>(), 96);
15758    static_assertions::const_assert_eq!(std::mem::align_of::<FilesystemInfo>(), 8);
15759
15760    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_bytes), 0);
15761
15762    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_bytes), 8);
15763
15764    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_nodes), 16);
15765
15766    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_nodes), 24);
15767
15768    static_assertions::const_assert_eq!(
15769        std::mem::offset_of!(FilesystemInfo, free_shared_pool_bytes),
15770        32
15771    );
15772
15773    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_id), 40);
15774
15775    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, block_size), 48);
15776
15777    static_assertions::const_assert_eq!(
15778        std::mem::offset_of!(FilesystemInfo, max_filename_size),
15779        52
15780    );
15781
15782    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_type), 56);
15783
15784    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, padding), 60);
15785
15786    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, name), 64);
15787
15788    impl ::fidl_next::Constrained for FilesystemInfo {
15789        type Constraint = ();
15790
15791        fn validate(
15792            _: ::fidl_next::Slot<'_, Self>,
15793            _: Self::Constraint,
15794        ) -> Result<(), ::fidl_next::ValidationError> {
15795            Ok(())
15796        }
15797    }
15798
15799    unsafe impl ::fidl_next::Wire for FilesystemInfo {
15800        type Narrowed<'de> = FilesystemInfo;
15801
15802        #[inline]
15803        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15804            ::fidl_next::munge! {
15805                let Self {
15806                    total_bytes,
15807                    used_bytes,
15808                    total_nodes,
15809                    used_nodes,
15810                    free_shared_pool_bytes,
15811                    fs_id,
15812                    block_size,
15813                    max_filename_size,
15814                    fs_type,
15815                    padding,
15816                    name,
15817
15818                } = &mut *out_;
15819            }
15820
15821            ::fidl_next::Wire::zero_padding(total_bytes);
15822
15823            ::fidl_next::Wire::zero_padding(used_bytes);
15824
15825            ::fidl_next::Wire::zero_padding(total_nodes);
15826
15827            ::fidl_next::Wire::zero_padding(used_nodes);
15828
15829            ::fidl_next::Wire::zero_padding(free_shared_pool_bytes);
15830
15831            ::fidl_next::Wire::zero_padding(fs_id);
15832
15833            ::fidl_next::Wire::zero_padding(block_size);
15834
15835            ::fidl_next::Wire::zero_padding(max_filename_size);
15836
15837            ::fidl_next::Wire::zero_padding(fs_type);
15838
15839            ::fidl_next::Wire::zero_padding(padding);
15840
15841            ::fidl_next::Wire::zero_padding(name);
15842        }
15843    }
15844
15845    unsafe impl<___D> ::fidl_next::Decode<___D> for FilesystemInfo
15846    where
15847        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15848    {
15849        fn decode(
15850            slot_: ::fidl_next::Slot<'_, Self>,
15851            decoder_: &mut ___D,
15852            _: (),
15853        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15854            ::fidl_next::munge! {
15855                let Self {
15856                    mut total_bytes,
15857                    mut used_bytes,
15858                    mut total_nodes,
15859                    mut used_nodes,
15860                    mut free_shared_pool_bytes,
15861                    mut fs_id,
15862                    mut block_size,
15863                    mut max_filename_size,
15864                    mut fs_type,
15865                    mut padding,
15866                    mut name,
15867
15868                } = slot_;
15869            }
15870
15871            let _field = total_bytes.as_mut();
15872
15873            ::fidl_next::Decode::decode(total_bytes.as_mut(), decoder_, ())?;
15874
15875            let _field = used_bytes.as_mut();
15876
15877            ::fidl_next::Decode::decode(used_bytes.as_mut(), decoder_, ())?;
15878
15879            let _field = total_nodes.as_mut();
15880
15881            ::fidl_next::Decode::decode(total_nodes.as_mut(), decoder_, ())?;
15882
15883            let _field = used_nodes.as_mut();
15884
15885            ::fidl_next::Decode::decode(used_nodes.as_mut(), decoder_, ())?;
15886
15887            let _field = free_shared_pool_bytes.as_mut();
15888
15889            ::fidl_next::Decode::decode(free_shared_pool_bytes.as_mut(), decoder_, ())?;
15890
15891            let _field = fs_id.as_mut();
15892
15893            ::fidl_next::Decode::decode(fs_id.as_mut(), decoder_, ())?;
15894
15895            let _field = block_size.as_mut();
15896
15897            ::fidl_next::Decode::decode(block_size.as_mut(), decoder_, ())?;
15898
15899            let _field = max_filename_size.as_mut();
15900
15901            ::fidl_next::Decode::decode(max_filename_size.as_mut(), decoder_, ())?;
15902
15903            let _field = fs_type.as_mut();
15904
15905            ::fidl_next::Decode::decode(fs_type.as_mut(), decoder_, ())?;
15906
15907            let _field = padding.as_mut();
15908
15909            ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
15910
15911            let _field = name.as_mut();
15912
15913            ::fidl_next::Decode::decode(name.as_mut(), decoder_, ())?;
15914
15915            Ok(())
15916        }
15917    }
15918
15919    impl ::fidl_next::IntoNatural for FilesystemInfo {
15920        type Natural = crate::natural::FilesystemInfo;
15921    }
15922
15923    /// The wire type corresponding to [`Service`].
15924    pub type Service = ::fidl_next::wire::Unit;
15925
15926    /// The wire type corresponding to [`SymlinkObject`].
15927    #[derive(Debug)]
15928    #[repr(C)]
15929    pub struct SymlinkObject<'de> {
15930        pub target: ::fidl_next::wire::Vector<'de, u8>,
15931    }
15932
15933    static_assertions::const_assert_eq!(std::mem::size_of::<SymlinkObject<'_>>(), 16);
15934    static_assertions::const_assert_eq!(std::mem::align_of::<SymlinkObject<'_>>(), 8);
15935
15936    static_assertions::const_assert_eq!(std::mem::offset_of!(SymlinkObject<'_>, target), 0);
15937
15938    impl ::fidl_next::Constrained for SymlinkObject<'_> {
15939        type Constraint = ();
15940
15941        fn validate(
15942            _: ::fidl_next::Slot<'_, Self>,
15943            _: Self::Constraint,
15944        ) -> Result<(), ::fidl_next::ValidationError> {
15945            Ok(())
15946        }
15947    }
15948
15949    unsafe impl ::fidl_next::Wire for SymlinkObject<'static> {
15950        type Narrowed<'de> = SymlinkObject<'de>;
15951
15952        #[inline]
15953        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15954            ::fidl_next::munge! {
15955                let Self {
15956                    target,
15957
15958                } = &mut *out_;
15959            }
15960
15961            ::fidl_next::Wire::zero_padding(target);
15962        }
15963    }
15964
15965    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkObject<'de>
15966    where
15967        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15968        ___D: ::fidl_next::Decoder<'de>,
15969    {
15970        fn decode(
15971            slot_: ::fidl_next::Slot<'_, Self>,
15972            decoder_: &mut ___D,
15973            _: (),
15974        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15975            ::fidl_next::munge! {
15976                let Self {
15977                    mut target,
15978
15979                } = slot_;
15980            }
15981
15982            let _field = target.as_mut();
15983            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
15984            ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
15985
15986            let target = unsafe { target.deref_unchecked() };
15987
15988            if target.len() > 4095 {
15989                return Err(::fidl_next::DecodeError::VectorTooLong {
15990                    size: target.len() as u64,
15991                    limit: 4095,
15992                });
15993            }
15994
15995            Ok(())
15996        }
15997    }
15998
15999    impl<'de> ::fidl_next::IntoNatural for SymlinkObject<'de> {
16000        type Natural = crate::natural::SymlinkObject;
16001    }
16002
16003    /// The wire type corresponding to [`WatchEvent`].
16004    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
16005    #[repr(transparent)]
16006    pub struct WatchEvent {
16007        pub(crate) value: u8,
16008    }
16009
16010    impl ::fidl_next::Constrained for WatchEvent {
16011        type Constraint = ();
16012
16013        fn validate(
16014            _: ::fidl_next::Slot<'_, Self>,
16015            _: Self::Constraint,
16016        ) -> Result<(), ::fidl_next::ValidationError> {
16017            Ok(())
16018        }
16019    }
16020
16021    unsafe impl ::fidl_next::Wire for WatchEvent {
16022        type Narrowed<'de> = Self;
16023
16024        #[inline]
16025        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
16026            // Wire enums have no padding
16027        }
16028    }
16029
16030    impl WatchEvent {
16031        pub const DELETED: WatchEvent = WatchEvent { value: 0 };
16032
16033        pub const ADDED: WatchEvent = WatchEvent { value: 1 };
16034
16035        pub const REMOVED: WatchEvent = WatchEvent { value: 2 };
16036
16037        pub const EXISTING: WatchEvent = WatchEvent { value: 3 };
16038
16039        pub const IDLE: WatchEvent = WatchEvent { value: 4 };
16040    }
16041
16042    unsafe impl<___D> ::fidl_next::Decode<___D> for WatchEvent
16043    where
16044        ___D: ?Sized,
16045    {
16046        fn decode(
16047            slot: ::fidl_next::Slot<'_, Self>,
16048            _: &mut ___D,
16049            _: (),
16050        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16051            ::fidl_next::munge!(let Self { value } = slot);
16052
16053            match u8::from(*value) {
16054                0 | 1 | 2 | 3 | 4 => (),
16055                unknown => {
16056                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
16057                }
16058            }
16059
16060            Ok(())
16061        }
16062    }
16063
16064    impl ::core::convert::From<crate::natural::WatchEvent> for WatchEvent {
16065        fn from(natural: crate::natural::WatchEvent) -> Self {
16066            match natural {
16067                crate::natural::WatchEvent::Deleted => WatchEvent::DELETED,
16068
16069                crate::natural::WatchEvent::Added => WatchEvent::ADDED,
16070
16071                crate::natural::WatchEvent::Removed => WatchEvent::REMOVED,
16072
16073                crate::natural::WatchEvent::Existing => WatchEvent::EXISTING,
16074
16075                crate::natural::WatchEvent::Idle => WatchEvent::IDLE,
16076            }
16077        }
16078    }
16079
16080    impl ::fidl_next::IntoNatural for WatchEvent {
16081        type Natural = crate::natural::WatchEvent;
16082    }
16083}
16084
16085pub mod wire_optional {
16086
16087    #[repr(transparent)]
16088    pub struct SelinuxContext<'de> {
16089        pub(crate) raw: ::fidl_next::wire::Union,
16090        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
16091    }
16092
16093    impl ::fidl_next::Constrained for SelinuxContext<'_> {
16094        type Constraint = ();
16095
16096        fn validate(
16097            _: ::fidl_next::Slot<'_, Self>,
16098            _: Self::Constraint,
16099        ) -> Result<(), ::fidl_next::ValidationError> {
16100            Ok(())
16101        }
16102    }
16103
16104    unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
16105        type Narrowed<'de> = SelinuxContext<'de>;
16106
16107        #[inline]
16108        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16109            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
16110            ::fidl_next::wire::Union::zero_padding(raw);
16111        }
16112    }
16113
16114    impl<'de> SelinuxContext<'de> {
16115        pub fn is_some(&self) -> bool {
16116            self.raw.is_some()
16117        }
16118
16119        pub fn is_none(&self) -> bool {
16120            self.raw.is_none()
16121        }
16122
16123        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
16124            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
16125        }
16126
16127        pub fn into_option(self) -> ::core::option::Option<crate::wire::SelinuxContext<'de>> {
16128            if self.is_some() {
16129                Some(crate::wire::SelinuxContext {
16130                    raw: self.raw,
16131                    _phantom: ::core::marker::PhantomData,
16132                })
16133            } else {
16134                None
16135            }
16136        }
16137    }
16138
16139    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
16140    where
16141        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16142        ___D: ::fidl_next::Decoder<'de>,
16143    {
16144        fn decode(
16145            mut slot: ::fidl_next::Slot<'_, Self>,
16146            decoder: &mut ___D,
16147            _: (),
16148        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16149            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
16150            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
16151                1 => {
16152                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
16153                        raw,
16154                        decoder,
16155                        (256, ()),
16156                    )?
16157                }
16158
16159                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
16160                    raw,
16161                    decoder,
16162                    (),
16163                )?,
16164
16165                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
16166                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
16167            }
16168
16169            Ok(())
16170        }
16171    }
16172
16173    impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
16174        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
16175            self.as_ref().fmt(f)
16176        }
16177    }
16178
16179    impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
16180        type Natural = ::core::option::Option<crate::natural::SelinuxContext>;
16181    }
16182}
16183
16184pub mod generic {
16185
16186    /// The generic type corresponding to [`AdvisoryLockRange`].
16187    pub struct AdvisoryLockRange<T0, T1, T2> {
16188        pub origin: T0,
16189
16190        pub offset: T1,
16191
16192        pub length: T2,
16193    }
16194
16195    unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
16196        for AdvisoryLockRange<T0, T1, T2>
16197    where
16198        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16199        T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
16200        T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
16201        T2: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
16202    {
16203        #[inline]
16204        fn encode(
16205            self,
16206            encoder_: &mut ___E,
16207            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
16208            _: (),
16209        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16210            ::fidl_next::munge! {
16211                let crate::wire::AdvisoryLockRange {
16212                    origin,
16213                    offset,
16214                    length,
16215
16216                } = out_;
16217            }
16218
16219            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
16220
16221            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
16222
16223            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
16224
16225            Ok(())
16226        }
16227    }
16228
16229    /// The generic type corresponding to [`AdvisoryLockingAdvisoryLockRequest`].
16230    pub struct AdvisoryLockingAdvisoryLockRequest<T0> {
16231        pub request: T0,
16232    }
16233
16234    unsafe impl<___E, T0>
16235        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
16236        for AdvisoryLockingAdvisoryLockRequest<T0>
16237    where
16238        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16239        ___E: ::fidl_next::Encoder,
16240        T0: ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>,
16241    {
16242        #[inline]
16243        fn encode(
16244            self,
16245            encoder_: &mut ___E,
16246            out_: &mut ::core::mem::MaybeUninit<
16247                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
16248            >,
16249            _: (),
16250        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16251            ::fidl_next::munge! {
16252                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
16253                    request,
16254
16255                } = out_;
16256            }
16257
16258            ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
16259
16260            Ok(())
16261        }
16262    }
16263
16264    /// The generic type corresponding to [`AdvisoryLockingAdvisoryLockResponse`].
16265    pub type AdvisoryLockingAdvisoryLockResponse = ();
16266
16267    /// The generic type corresponding to [`NodeAttributes`].
16268    pub struct NodeAttributes<T0, T1, T2, T3, T4, T5, T6> {
16269        pub mode: T0,
16270
16271        pub id: T1,
16272
16273        pub content_size: T2,
16274
16275        pub storage_size: T3,
16276
16277        pub link_count: T4,
16278
16279        pub creation_time: T5,
16280
16281        pub modification_time: T6,
16282    }
16283
16284    unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
16285        ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>
16286        for NodeAttributes<T0, T1, T2, T3, T4, T5, T6>
16287    where
16288        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16289        T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
16290        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16291        T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16292        T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16293        T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16294        T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16295        T6: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16296    {
16297        #[inline]
16298        fn encode(
16299            self,
16300            encoder_: &mut ___E,
16301            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
16302            _: (),
16303        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16304            ::fidl_next::munge! {
16305                let crate::wire::NodeAttributes {
16306                    mode,
16307                    id,
16308                    content_size,
16309                    storage_size,
16310                    link_count,
16311                    creation_time,
16312                    modification_time,
16313
16314                } = out_;
16315            }
16316
16317            ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
16318
16319            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
16320
16321            ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
16322
16323            ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
16324
16325            ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
16326
16327            ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
16328
16329            ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
16330
16331            Ok(())
16332        }
16333    }
16334
16335    /// The generic type corresponding to [`NodeQueryFilesystemResponse`].
16336    pub struct NodeQueryFilesystemResponse<T0, T1> {
16337        pub s: T0,
16338
16339        pub info: T1,
16340    }
16341
16342    unsafe impl<___E, T0, T1>
16343        ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
16344        for NodeQueryFilesystemResponse<T0, T1>
16345    where
16346        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16347        ___E: ::fidl_next::Encoder,
16348        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16349        T1: ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>, ___E>,
16350    {
16351        #[inline]
16352        fn encode(
16353            self,
16354            encoder_: &mut ___E,
16355            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
16356            _: (),
16357        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16358            ::fidl_next::munge! {
16359                let crate::wire::NodeQueryFilesystemResponse {
16360                    s,
16361                    info,
16362
16363                } = out_;
16364            }
16365
16366            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16367
16368            ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
16369
16370            Ok(())
16371        }
16372    }
16373
16374    /// The generic type corresponding to [`NodeUpdateAttributesResponse`].
16375    pub type NodeUpdateAttributesResponse = ();
16376
16377    /// The generic type corresponding to [`NodeSyncResponse`].
16378    pub type NodeSyncResponse = ();
16379
16380    /// The generic type corresponding to [`DirectoryReadDirentsRequest`].
16381    pub struct DirectoryReadDirentsRequest<T0> {
16382        pub max_bytes: T0,
16383    }
16384
16385    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
16386        for DirectoryReadDirentsRequest<T0>
16387    where
16388        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16389        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16390    {
16391        #[inline]
16392        fn encode(
16393            self,
16394            encoder_: &mut ___E,
16395            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
16396            _: (),
16397        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16398            ::fidl_next::munge! {
16399                let crate::wire::DirectoryReadDirentsRequest {
16400                    max_bytes,
16401
16402                } = out_;
16403            }
16404
16405            ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
16406
16407            Ok(())
16408        }
16409    }
16410
16411    /// The generic type corresponding to [`DirectoryReadDirentsResponse`].
16412    pub struct DirectoryReadDirentsResponse<T0, T1> {
16413        pub s: T0,
16414
16415        pub dirents: T1,
16416    }
16417
16418    unsafe impl<___E, T0, T1>
16419        ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
16420        for DirectoryReadDirentsResponse<T0, T1>
16421    where
16422        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16423        ___E: ::fidl_next::Encoder,
16424        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16425        T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16426    {
16427        #[inline]
16428        fn encode(
16429            self,
16430            encoder_: &mut ___E,
16431            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
16432            _: (),
16433        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16434            ::fidl_next::munge! {
16435                let crate::wire::DirectoryReadDirentsResponse {
16436                    s,
16437                    dirents,
16438
16439                } = out_;
16440            }
16441
16442            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16443
16444            ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
16445
16446            Ok(())
16447        }
16448    }
16449
16450    /// The generic type corresponding to [`DirectoryRewindResponse`].
16451    pub struct DirectoryRewindResponse<T0> {
16452        pub s: T0,
16453    }
16454
16455    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
16456        for DirectoryRewindResponse<T0>
16457    where
16458        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16459        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16460    {
16461        #[inline]
16462        fn encode(
16463            self,
16464            encoder_: &mut ___E,
16465            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
16466            _: (),
16467        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16468            ::fidl_next::munge! {
16469                let crate::wire::DirectoryRewindResponse {
16470                    s,
16471
16472                } = out_;
16473            }
16474
16475            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16476
16477            Ok(())
16478        }
16479    }
16480
16481    /// The generic type corresponding to [`DirectoryLinkResponse`].
16482    pub struct DirectoryLinkResponse<T0> {
16483        pub s: T0,
16484    }
16485
16486    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
16487        for DirectoryLinkResponse<T0>
16488    where
16489        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16490        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16491    {
16492        #[inline]
16493        fn encode(
16494            self,
16495            encoder_: &mut ___E,
16496            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
16497            _: (),
16498        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16499            ::fidl_next::munge! {
16500                let crate::wire::DirectoryLinkResponse {
16501                    s,
16502
16503                } = out_;
16504            }
16505
16506            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16507
16508            Ok(())
16509        }
16510    }
16511
16512    /// The generic type corresponding to [`DirectoryUnlinkRequest`].
16513    pub struct DirectoryUnlinkRequest<T0, T1> {
16514        pub name: T0,
16515
16516        pub options: T1,
16517    }
16518
16519    unsafe impl<___E, T0, T1>
16520        ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
16521        for DirectoryUnlinkRequest<T0, T1>
16522    where
16523        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16524        ___E: ::fidl_next::Encoder,
16525        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
16526        T1: ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>,
16527    {
16528        #[inline]
16529        fn encode(
16530            self,
16531            encoder_: &mut ___E,
16532            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
16533            _: (),
16534        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16535            ::fidl_next::munge! {
16536                let crate::wire::DirectoryUnlinkRequest {
16537                    name,
16538                    options,
16539
16540                } = out_;
16541            }
16542
16543            ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
16544
16545            ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
16546
16547            Ok(())
16548        }
16549    }
16550
16551    /// The generic type corresponding to [`DirectoryUnlinkResponse`].
16552    pub type DirectoryUnlinkResponse = ();
16553
16554    /// The generic type corresponding to [`DirectoryRenameResponse`].
16555    pub type DirectoryRenameResponse = ();
16556
16557    /// The generic type corresponding to [`DirectoryWatchResponse`].
16558    pub struct DirectoryWatchResponse<T0> {
16559        pub s: T0,
16560    }
16561
16562    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
16563        for DirectoryWatchResponse<T0>
16564    where
16565        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16566        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16567    {
16568        #[inline]
16569        fn encode(
16570            self,
16571            encoder_: &mut ___E,
16572            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
16573            _: (),
16574        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16575            ::fidl_next::munge! {
16576                let crate::wire::DirectoryWatchResponse {
16577                    s,
16578
16579                } = out_;
16580            }
16581
16582            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16583
16584            Ok(())
16585        }
16586    }
16587
16588    /// The generic type corresponding to [`NodeGetExtendedAttributeRequest`].
16589    pub struct NodeGetExtendedAttributeRequest<T0> {
16590        pub name: T0,
16591    }
16592
16593    unsafe impl<___E, T0>
16594        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
16595        for NodeGetExtendedAttributeRequest<T0>
16596    where
16597        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16598        ___E: ::fidl_next::Encoder,
16599        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16600    {
16601        #[inline]
16602        fn encode(
16603            self,
16604            encoder_: &mut ___E,
16605            out_: &mut ::core::mem::MaybeUninit<
16606                crate::wire::NodeGetExtendedAttributeRequest<'static>,
16607            >,
16608            _: (),
16609        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16610            ::fidl_next::munge! {
16611                let crate::wire::NodeGetExtendedAttributeRequest {
16612                    name,
16613
16614                } = out_;
16615            }
16616
16617            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
16618
16619            Ok(())
16620        }
16621    }
16622
16623    /// The generic type corresponding to [`NodeSetExtendedAttributeResponse`].
16624    pub type NodeSetExtendedAttributeResponse = ();
16625
16626    /// The generic type corresponding to [`NodeRemoveExtendedAttributeRequest`].
16627    pub struct NodeRemoveExtendedAttributeRequest<T0> {
16628        pub name: T0,
16629    }
16630
16631    unsafe impl<___E, T0>
16632        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
16633        for NodeRemoveExtendedAttributeRequest<T0>
16634    where
16635        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16636        ___E: ::fidl_next::Encoder,
16637        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16638    {
16639        #[inline]
16640        fn encode(
16641            self,
16642            encoder_: &mut ___E,
16643            out_: &mut ::core::mem::MaybeUninit<
16644                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
16645            >,
16646            _: (),
16647        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16648            ::fidl_next::munge! {
16649                let crate::wire::NodeRemoveExtendedAttributeRequest {
16650                    name,
16651
16652                } = out_;
16653            }
16654
16655            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
16656
16657            Ok(())
16658        }
16659    }
16660
16661    /// The generic type corresponding to [`NodeRemoveExtendedAttributeResponse`].
16662    pub type NodeRemoveExtendedAttributeResponse = ();
16663
16664    /// The generic type corresponding to [`DirectoryCreateSymlinkResponse`].
16665    pub type DirectoryCreateSymlinkResponse = ();
16666
16667    /// The generic type corresponding to [`NodeSetFlagsResponse`].
16668    pub type NodeSetFlagsResponse = ();
16669
16670    /// The generic type corresponding to [`NodeDeprecatedGetAttrResponse`].
16671    pub struct NodeDeprecatedGetAttrResponse<T0, T1> {
16672        pub s: T0,
16673
16674        pub attributes: T1,
16675    }
16676
16677    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
16678        for NodeDeprecatedGetAttrResponse<T0, T1>
16679    where
16680        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16681        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16682        T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
16683    {
16684        #[inline]
16685        fn encode(
16686            self,
16687            encoder_: &mut ___E,
16688            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
16689            _: (),
16690        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16691            ::fidl_next::munge! {
16692                let crate::wire::NodeDeprecatedGetAttrResponse {
16693                    s,
16694                    attributes,
16695
16696                } = out_;
16697            }
16698
16699            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16700
16701            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
16702
16703            Ok(())
16704        }
16705    }
16706
16707    /// The generic type corresponding to [`NodeDeprecatedSetAttrRequest`].
16708    pub struct NodeDeprecatedSetAttrRequest<T0, T1> {
16709        pub flags: T0,
16710
16711        pub attributes: T1,
16712    }
16713
16714    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
16715        for NodeDeprecatedSetAttrRequest<T0, T1>
16716    where
16717        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16718        T0: ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>,
16719        T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
16720    {
16721        #[inline]
16722        fn encode(
16723            self,
16724            encoder_: &mut ___E,
16725            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
16726            _: (),
16727        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16728            ::fidl_next::munge! {
16729                let crate::wire::NodeDeprecatedSetAttrRequest {
16730                    flags,
16731                    attributes,
16732
16733                } = out_;
16734            }
16735
16736            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16737
16738            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
16739
16740            Ok(())
16741        }
16742    }
16743
16744    /// The generic type corresponding to [`NodeDeprecatedSetAttrResponse`].
16745    pub struct NodeDeprecatedSetAttrResponse<T0> {
16746        pub s: T0,
16747    }
16748
16749    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
16750        for NodeDeprecatedSetAttrResponse<T0>
16751    where
16752        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16753        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16754    {
16755        #[inline]
16756        fn encode(
16757            self,
16758            encoder_: &mut ___E,
16759            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
16760            _: (),
16761        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16762            ::fidl_next::munge! {
16763                let crate::wire::NodeDeprecatedSetAttrResponse {
16764                    s,
16765
16766                } = out_;
16767            }
16768
16769            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16770
16771            Ok(())
16772        }
16773    }
16774
16775    /// The generic type corresponding to [`NodeDeprecatedGetFlagsResponse`].
16776    pub struct NodeDeprecatedGetFlagsResponse<T0, T1> {
16777        pub s: T0,
16778
16779        pub flags: T1,
16780    }
16781
16782    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
16783        for NodeDeprecatedGetFlagsResponse<T0, T1>
16784    where
16785        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16786        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16787        T1: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
16788    {
16789        #[inline]
16790        fn encode(
16791            self,
16792            encoder_: &mut ___E,
16793            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
16794            _: (),
16795        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16796            ::fidl_next::munge! {
16797                let crate::wire::NodeDeprecatedGetFlagsResponse {
16798                    s,
16799                    flags,
16800
16801                } = out_;
16802            }
16803
16804            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16805
16806            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16807
16808            Ok(())
16809        }
16810    }
16811
16812    /// The generic type corresponding to [`NodeDeprecatedSetFlagsRequest`].
16813    pub struct NodeDeprecatedSetFlagsRequest<T0> {
16814        pub flags: T0,
16815    }
16816
16817    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
16818        for NodeDeprecatedSetFlagsRequest<T0>
16819    where
16820        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16821        T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
16822    {
16823        #[inline]
16824        fn encode(
16825            self,
16826            encoder_: &mut ___E,
16827            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
16828            _: (),
16829        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16830            ::fidl_next::munge! {
16831                let crate::wire::NodeDeprecatedSetFlagsRequest {
16832                    flags,
16833
16834                } = out_;
16835            }
16836
16837            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16838
16839            Ok(())
16840        }
16841    }
16842
16843    /// The generic type corresponding to [`NodeDeprecatedSetFlagsResponse`].
16844    pub struct NodeDeprecatedSetFlagsResponse<T0> {
16845        pub s: T0,
16846    }
16847
16848    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
16849        for NodeDeprecatedSetFlagsResponse<T0>
16850    where
16851        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16852        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16853    {
16854        #[inline]
16855        fn encode(
16856            self,
16857            encoder_: &mut ___E,
16858            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
16859            _: (),
16860        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16861            ::fidl_next::munge! {
16862                let crate::wire::NodeDeprecatedSetFlagsResponse {
16863                    s,
16864
16865                } = out_;
16866            }
16867
16868            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16869
16870            Ok(())
16871        }
16872    }
16873
16874    /// The generic type corresponding to [`NodeGetFlagsResponse`].
16875    pub struct NodeGetFlagsResponse<T0> {
16876        pub flags: T0,
16877    }
16878
16879    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
16880        for NodeGetFlagsResponse<T0>
16881    where
16882        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16883        T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
16884    {
16885        #[inline]
16886        fn encode(
16887            self,
16888            encoder_: &mut ___E,
16889            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
16890            _: (),
16891        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16892            ::fidl_next::munge! {
16893                let crate::wire::NodeGetFlagsResponse {
16894                    flags,
16895
16896                } = out_;
16897            }
16898
16899            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16900
16901            Ok(())
16902        }
16903    }
16904
16905    /// The generic type corresponding to [`NodeSetFlagsRequest`].
16906    pub struct NodeSetFlagsRequest<T0> {
16907        pub flags: T0,
16908    }
16909
16910    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
16911        for NodeSetFlagsRequest<T0>
16912    where
16913        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16914        T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
16915    {
16916        #[inline]
16917        fn encode(
16918            self,
16919            encoder_: &mut ___E,
16920            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
16921            _: (),
16922        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16923            ::fidl_next::munge! {
16924                let crate::wire::NodeSetFlagsRequest {
16925                    flags,
16926
16927                } = out_;
16928            }
16929
16930            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16931
16932            Ok(())
16933        }
16934    }
16935
16936    /// The generic type corresponding to [`EmptyStruct`].
16937    pub type EmptyStruct = ();
16938
16939    /// The generic type corresponding to [`NodeAttributes2`].
16940    pub struct NodeAttributes2<T0, T1> {
16941        pub mutable_attributes: T0,
16942
16943        pub immutable_attributes: T1,
16944    }
16945
16946    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
16947        for NodeAttributes2<T0, T1>
16948    where
16949        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16950        ___E: ::fidl_next::Encoder,
16951        T0: ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>,
16952        T1: ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>,
16953    {
16954        #[inline]
16955        fn encode(
16956            self,
16957            encoder_: &mut ___E,
16958            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
16959            _: (),
16960        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16961            ::fidl_next::munge! {
16962                let crate::wire::NodeAttributes2 {
16963                    mutable_attributes,
16964                    immutable_attributes,
16965
16966                } = out_;
16967            }
16968
16969            ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
16970
16971            ::fidl_next::Encode::encode(
16972                self.immutable_attributes,
16973                encoder_,
16974                immutable_attributes,
16975                (),
16976            )?;
16977
16978            Ok(())
16979        }
16980    }
16981
16982    /// The generic type corresponding to [`NodeGetAttributesRequest`].
16983    pub struct NodeGetAttributesRequest<T0> {
16984        pub query: T0,
16985    }
16986
16987    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
16988        for NodeGetAttributesRequest<T0>
16989    where
16990        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16991        T0: ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>,
16992    {
16993        #[inline]
16994        fn encode(
16995            self,
16996            encoder_: &mut ___E,
16997            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
16998            _: (),
16999        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17000            ::fidl_next::munge! {
17001                let crate::wire::NodeGetAttributesRequest {
17002                    query,
17003
17004                } = out_;
17005            }
17006
17007            ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
17008
17009            Ok(())
17010        }
17011    }
17012
17013    /// The generic type corresponding to [`DirectoryObject`].
17014    pub type DirectoryObject = ();
17015
17016    /// The generic type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
17017    pub struct ExtendedAttributeIteratorGetNextResponse<T0, T1> {
17018        pub attributes: T0,
17019
17020        pub last: T1,
17021    }
17022
17023    unsafe impl<___E, T0, T1>
17024        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
17025        for ExtendedAttributeIteratorGetNextResponse<T0, T1>
17026    where
17027        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17028        ___E: ::fidl_next::Encoder,
17029        T0: ::fidl_next::Encode<
17030                ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Vector<'static, u8>>,
17031                ___E,
17032            >,
17033        T1: ::fidl_next::Encode<bool, ___E>,
17034    {
17035        #[inline]
17036        fn encode(
17037            self,
17038            encoder_: &mut ___E,
17039            out_: &mut ::core::mem::MaybeUninit<
17040                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
17041            >,
17042            _: (),
17043        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17044            ::fidl_next::munge! {
17045                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
17046                    attributes,
17047                    last,
17048
17049                } = out_;
17050            }
17051
17052            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
17053
17054            ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
17055
17056            Ok(())
17057        }
17058    }
17059
17060    /// The generic type corresponding to [`ReadableReadRequest`].
17061    pub struct ReadableReadRequest<T0> {
17062        pub count: T0,
17063    }
17064
17065    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
17066        for ReadableReadRequest<T0>
17067    where
17068        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17069        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17070    {
17071        #[inline]
17072        fn encode(
17073            self,
17074            encoder_: &mut ___E,
17075            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
17076            _: (),
17077        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17078            ::fidl_next::munge! {
17079                let crate::wire::ReadableReadRequest {
17080                    count,
17081
17082                } = out_;
17083            }
17084
17085            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
17086
17087            Ok(())
17088        }
17089    }
17090
17091    /// The generic type corresponding to [`ReadableReadResponse`].
17092    pub struct ReadableReadResponse<T0> {
17093        pub data: T0,
17094    }
17095
17096    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
17097        for ReadableReadResponse<T0>
17098    where
17099        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17100        ___E: ::fidl_next::Encoder,
17101        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17102    {
17103        #[inline]
17104        fn encode(
17105            self,
17106            encoder_: &mut ___E,
17107            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
17108            _: (),
17109        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17110            ::fidl_next::munge! {
17111                let crate::wire::ReadableReadResponse {
17112                    data,
17113
17114                } = out_;
17115            }
17116
17117            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17118
17119            Ok(())
17120        }
17121    }
17122
17123    /// The generic type corresponding to [`WritableWriteRequest`].
17124    pub struct WritableWriteRequest<T0> {
17125        pub data: T0,
17126    }
17127
17128    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
17129        for WritableWriteRequest<T0>
17130    where
17131        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17132        ___E: ::fidl_next::Encoder,
17133        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17134    {
17135        #[inline]
17136        fn encode(
17137            self,
17138            encoder_: &mut ___E,
17139            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
17140            _: (),
17141        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17142            ::fidl_next::munge! {
17143                let crate::wire::WritableWriteRequest {
17144                    data,
17145
17146                } = out_;
17147            }
17148
17149            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17150
17151            Ok(())
17152        }
17153    }
17154
17155    /// The generic type corresponding to [`WritableWriteResponse`].
17156    pub struct WritableWriteResponse<T0> {
17157        pub actual_count: T0,
17158    }
17159
17160    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
17161        for WritableWriteResponse<T0>
17162    where
17163        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17164        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17165    {
17166        #[inline]
17167        fn encode(
17168            self,
17169            encoder_: &mut ___E,
17170            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
17171            _: (),
17172        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17173            ::fidl_next::munge! {
17174                let crate::wire::WritableWriteResponse {
17175                    actual_count,
17176
17177                } = out_;
17178            }
17179
17180            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
17181
17182            Ok(())
17183        }
17184    }
17185
17186    /// The generic type corresponding to [`FileSeekRequest`].
17187    pub struct FileSeekRequest<T0, T1> {
17188        pub origin: T0,
17189
17190        pub offset: T1,
17191    }
17192
17193    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
17194        for FileSeekRequest<T0, T1>
17195    where
17196        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17197        T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
17198        T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
17199    {
17200        #[inline]
17201        fn encode(
17202            self,
17203            encoder_: &mut ___E,
17204            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
17205            _: (),
17206        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17207            ::fidl_next::munge! {
17208                let crate::wire::FileSeekRequest {
17209                    origin,
17210                    offset,
17211
17212                } = out_;
17213            }
17214
17215            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
17216
17217            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17218
17219            Ok(())
17220        }
17221    }
17222
17223    /// The generic type corresponding to [`FileSeekResponse`].
17224    pub struct FileSeekResponse<T0> {
17225        pub offset_from_start: T0,
17226    }
17227
17228    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
17229        for FileSeekResponse<T0>
17230    where
17231        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17232        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17233    {
17234        #[inline]
17235        fn encode(
17236            self,
17237            encoder_: &mut ___E,
17238            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
17239            _: (),
17240        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17241            ::fidl_next::munge! {
17242                let crate::wire::FileSeekResponse {
17243                    offset_from_start,
17244
17245                } = out_;
17246            }
17247
17248            ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
17249
17250            Ok(())
17251        }
17252    }
17253
17254    /// The generic type corresponding to [`FileReadAtRequest`].
17255    pub struct FileReadAtRequest<T0, T1> {
17256        pub count: T0,
17257
17258        pub offset: T1,
17259    }
17260
17261    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
17262        for FileReadAtRequest<T0, T1>
17263    where
17264        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17265        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17266        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17267    {
17268        #[inline]
17269        fn encode(
17270            self,
17271            encoder_: &mut ___E,
17272            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
17273            _: (),
17274        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17275            ::fidl_next::munge! {
17276                let crate::wire::FileReadAtRequest {
17277                    count,
17278                    offset,
17279
17280                } = out_;
17281            }
17282
17283            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
17284
17285            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17286
17287            Ok(())
17288        }
17289    }
17290
17291    /// The generic type corresponding to [`FileReadAtResponse`].
17292    pub struct FileReadAtResponse<T0> {
17293        pub data: T0,
17294    }
17295
17296    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
17297        for FileReadAtResponse<T0>
17298    where
17299        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17300        ___E: ::fidl_next::Encoder,
17301        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17302    {
17303        #[inline]
17304        fn encode(
17305            self,
17306            encoder_: &mut ___E,
17307            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
17308            _: (),
17309        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17310            ::fidl_next::munge! {
17311                let crate::wire::FileReadAtResponse {
17312                    data,
17313
17314                } = out_;
17315            }
17316
17317            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17318
17319            Ok(())
17320        }
17321    }
17322
17323    /// The generic type corresponding to [`FileWriteAtRequest`].
17324    pub struct FileWriteAtRequest<T0, T1> {
17325        pub data: T0,
17326
17327        pub offset: T1,
17328    }
17329
17330    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
17331        for FileWriteAtRequest<T0, T1>
17332    where
17333        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17334        ___E: ::fidl_next::Encoder,
17335        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17336        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17337    {
17338        #[inline]
17339        fn encode(
17340            self,
17341            encoder_: &mut ___E,
17342            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
17343            _: (),
17344        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17345            ::fidl_next::munge! {
17346                let crate::wire::FileWriteAtRequest {
17347                    data,
17348                    offset,
17349
17350                } = out_;
17351            }
17352
17353            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17354
17355            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17356
17357            Ok(())
17358        }
17359    }
17360
17361    /// The generic type corresponding to [`FileWriteAtResponse`].
17362    pub struct FileWriteAtResponse<T0> {
17363        pub actual_count: T0,
17364    }
17365
17366    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
17367        for FileWriteAtResponse<T0>
17368    where
17369        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17370        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17371    {
17372        #[inline]
17373        fn encode(
17374            self,
17375            encoder_: &mut ___E,
17376            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
17377            _: (),
17378        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17379            ::fidl_next::munge! {
17380                let crate::wire::FileWriteAtResponse {
17381                    actual_count,
17382
17383                } = out_;
17384            }
17385
17386            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
17387
17388            Ok(())
17389        }
17390    }
17391
17392    /// The generic type corresponding to [`FileResizeRequest`].
17393    pub struct FileResizeRequest<T0> {
17394        pub length: T0,
17395    }
17396
17397    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
17398        for FileResizeRequest<T0>
17399    where
17400        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17401        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17402    {
17403        #[inline]
17404        fn encode(
17405            self,
17406            encoder_: &mut ___E,
17407            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
17408            _: (),
17409        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17410            ::fidl_next::munge! {
17411                let crate::wire::FileResizeRequest {
17412                    length,
17413
17414                } = out_;
17415            }
17416
17417            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
17418
17419            Ok(())
17420        }
17421    }
17422
17423    /// The generic type corresponding to [`FileResizeResponse`].
17424    pub type FileResizeResponse = ();
17425
17426    /// The generic type corresponding to [`FileGetBackingMemoryRequest`].
17427    pub struct FileGetBackingMemoryRequest<T0> {
17428        pub flags: T0,
17429    }
17430
17431    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
17432        for FileGetBackingMemoryRequest<T0>
17433    where
17434        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17435        T0: ::fidl_next::Encode<crate::wire::VmoFlags, ___E>,
17436    {
17437        #[inline]
17438        fn encode(
17439            self,
17440            encoder_: &mut ___E,
17441            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
17442            _: (),
17443        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17444            ::fidl_next::munge! {
17445                let crate::wire::FileGetBackingMemoryRequest {
17446                    flags,
17447
17448                } = out_;
17449            }
17450
17451            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
17452
17453            Ok(())
17454        }
17455    }
17456
17457    /// The generic type corresponding to [`LinkableLinkIntoResponse`].
17458    pub type LinkableLinkIntoResponse = ();
17459
17460    /// The generic type corresponding to [`FileAllocateResponse`].
17461    pub type FileAllocateResponse = ();
17462
17463    /// The generic type corresponding to [`FileEnableVerityResponse`].
17464    pub type FileEnableVerityResponse = ();
17465
17466    /// The generic type corresponding to [`FilesystemInfo`].
17467    pub struct FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
17468        pub total_bytes: T0,
17469
17470        pub used_bytes: T1,
17471
17472        pub total_nodes: T2,
17473
17474        pub used_nodes: T3,
17475
17476        pub free_shared_pool_bytes: T4,
17477
17478        pub fs_id: T5,
17479
17480        pub block_size: T6,
17481
17482        pub max_filename_size: T7,
17483
17484        pub fs_type: T8,
17485
17486        pub padding: T9,
17487
17488        pub name: T10,
17489    }
17490
17491    unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
17492        ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>
17493        for FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
17494    where
17495        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17496        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17497        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17498        T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17499        T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17500        T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17501        T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17502        T6: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17503        T7: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17504        T8: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17505        T9: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17506        T10: ::fidl_next::Encode<[i8; 32], ___E>,
17507    {
17508        #[inline]
17509        fn encode(
17510            self,
17511            encoder_: &mut ___E,
17512            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
17513            _: (),
17514        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17515            ::fidl_next::munge! {
17516                let crate::wire::FilesystemInfo {
17517                    total_bytes,
17518                    used_bytes,
17519                    total_nodes,
17520                    used_nodes,
17521                    free_shared_pool_bytes,
17522                    fs_id,
17523                    block_size,
17524                    max_filename_size,
17525                    fs_type,
17526                    padding,
17527                    name,
17528
17529                } = out_;
17530            }
17531
17532            ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
17533
17534            ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
17535
17536            ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
17537
17538            ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
17539
17540            ::fidl_next::Encode::encode(
17541                self.free_shared_pool_bytes,
17542                encoder_,
17543                free_shared_pool_bytes,
17544                (),
17545            )?;
17546
17547            ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
17548
17549            ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
17550
17551            ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
17552
17553            ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
17554
17555            ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
17556
17557            ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
17558
17559            Ok(())
17560        }
17561    }
17562
17563    /// The generic type corresponding to [`Service`].
17564    pub type Service = ();
17565
17566    /// The generic type corresponding to [`SymlinkObject`].
17567    pub struct SymlinkObject<T0> {
17568        pub target: T0,
17569    }
17570
17571    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
17572        for SymlinkObject<T0>
17573    where
17574        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17575        ___E: ::fidl_next::Encoder,
17576        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17577    {
17578        #[inline]
17579        fn encode(
17580            self,
17581            encoder_: &mut ___E,
17582            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
17583            _: (),
17584        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17585            ::fidl_next::munge! {
17586                let crate::wire::SymlinkObject {
17587                    target,
17588
17589                } = out_;
17590            }
17591
17592            ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
17593
17594            Ok(())
17595        }
17596    }
17597}
17598
17599pub use self::natural::*;
17600
17601/// The type corresponding to the AdvisoryLocking protocol.
17602#[doc = " Advisory locking protocol.\n\n This protocol is intended to be composed into the |File| protocol to\n provide support for advisory locking.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n These primitives are designed to support the flock() and fcntl(),\n specifically F_SETLK, F_SETLKW, and F_GETLK, functionality that code\n running on Fuchsia expects from other operating systems.\n"]
17603#[derive(PartialEq, Debug)]
17604pub struct AdvisoryLocking;
17605
17606#[cfg(target_os = "fuchsia")]
17607impl ::fidl_next::HasTransport for AdvisoryLocking {
17608    type Transport = ::fidl_next::fuchsia::zx::Channel;
17609}
17610
17611pub mod advisory_locking {
17612    pub mod prelude {
17613        pub use crate::{
17614            AdvisoryLocking, AdvisoryLockingClientHandler, AdvisoryLockingLocalClientHandler,
17615            AdvisoryLockingLocalServerHandler, AdvisoryLockingServerHandler, advisory_locking,
17616        };
17617
17618        pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
17619
17620        pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
17621    }
17622
17623    pub struct AdvisoryLock;
17624
17625    impl ::fidl_next::Method for AdvisoryLock {
17626        const ORDINAL: u64 = 7992130864415541162;
17627        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17628            ::fidl_next::protocol::Flexibility::Strict;
17629
17630        type Protocol = crate::AdvisoryLocking;
17631
17632        type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
17633    }
17634
17635    impl ::fidl_next::TwoWayMethod for AdvisoryLock {
17636        type Response = ::fidl_next::wire::Result<
17637            'static,
17638            crate::wire::AdvisoryLockingAdvisoryLockResponse,
17639            ::fidl_next::wire::fuchsia::Status,
17640        >;
17641    }
17642
17643    impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
17644        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17645
17646        fn respond(response: ___R) -> Self::Output {
17647            ::core::result::Result::Ok(response)
17648        }
17649    }
17650
17651    impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
17652        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17653
17654        fn respond_err(response: ___R) -> Self::Output {
17655            ::core::result::Result::Err(response)
17656        }
17657    }
17658
17659    mod ___detail {
17660        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::AdvisoryLocking
17661        where
17662            ___T: ::fidl_next::Transport,
17663        {
17664            type Client = AdvisoryLockingClient<___T>;
17665            type Server = AdvisoryLockingServer<___T>;
17666        }
17667
17668        /// The client for the `AdvisoryLocking` protocol.
17669        #[repr(transparent)]
17670        pub struct AdvisoryLockingClient<___T: ::fidl_next::Transport> {
17671            #[allow(dead_code)]
17672            client: ::fidl_next::protocol::Client<___T>,
17673        }
17674
17675        impl<___T> AdvisoryLockingClient<___T>
17676        where
17677            ___T: ::fidl_next::Transport,
17678        {
17679            #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
17680            pub fn advisory_lock(
17681                &self,
17682
17683                request: impl ::fidl_next::Encode<
17684                    crate::wire::AdvisoryLockRequest<'static>,
17685                    <___T as ::fidl_next::Transport>::SendBuffer,
17686                >,
17687            ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
17688            where
17689                <___T as ::fidl_next::Transport>::SendBuffer:
17690                    ::fidl_next::encoder::InternalHandleEncoder,
17691                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17692            {
17693                self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
17694                    request,
17695                })
17696            }
17697
17698            #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
17699            pub fn advisory_lock_with<___R>(
17700                &self,
17701                request: ___R,
17702            ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
17703            where
17704                ___R: ::fidl_next::Encode<
17705                        crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
17706                        <___T as ::fidl_next::Transport>::SendBuffer,
17707                    >,
17708            {
17709                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17710                    7992130864415541162,
17711                    <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
17712                    request,
17713                ))
17714            }
17715        }
17716
17717        /// The server for the `AdvisoryLocking` protocol.
17718        #[repr(transparent)]
17719        pub struct AdvisoryLockingServer<___T: ::fidl_next::Transport> {
17720            server: ::fidl_next::protocol::Server<___T>,
17721        }
17722
17723        impl<___T> AdvisoryLockingServer<___T> where ___T: ::fidl_next::Transport {}
17724    }
17725}
17726
17727#[diagnostic::on_unimplemented(
17728    note = "If {Self} implements the non-local AdvisoryLockingClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
17729)]
17730
17731/// A client handler for the AdvisoryLocking protocol.
17732///
17733/// See [`AdvisoryLocking`] for more details.
17734pub trait AdvisoryLockingLocalClientHandler<
17735    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17736    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17737>
17738{
17739}
17740
17741impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for AdvisoryLocking
17742where
17743    ___H: AdvisoryLockingLocalClientHandler<___T>,
17744    ___T: ::fidl_next::Transport,
17745{
17746    async fn on_event(
17747        handler: &mut ___H,
17748        mut message: ::fidl_next::Message<___T>,
17749    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17750        match *message.header().ordinal {
17751            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17752        }
17753    }
17754}
17755
17756#[diagnostic::on_unimplemented(
17757    note = "If {Self} implements the non-local AdvisoryLockingServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
17758)]
17759
17760/// A server handler for the AdvisoryLocking protocol.
17761///
17762/// See [`AdvisoryLocking`] for more details.
17763pub trait AdvisoryLockingLocalServerHandler<
17764    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17765    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17766>
17767{
17768    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
17769    fn advisory_lock(
17770        &mut self,
17771
17772        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17773
17774        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17775    ) -> impl ::core::future::Future<Output = ()>;
17776}
17777
17778impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for AdvisoryLocking
17779where
17780    ___H: AdvisoryLockingLocalServerHandler<___T>,
17781    ___T: ::fidl_next::Transport,
17782    for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
17783            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17784            Constraint = (),
17785        >,
17786{
17787    async fn on_one_way(
17788        handler: &mut ___H,
17789        mut message: ::fidl_next::Message<___T>,
17790    ) -> ::core::result::Result<
17791        (),
17792        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17793    > {
17794        match *message.header().ordinal {
17795            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17796        }
17797    }
17798
17799    async fn on_two_way(
17800        handler: &mut ___H,
17801        mut message: ::fidl_next::Message<___T>,
17802        responder: ::fidl_next::protocol::Responder<___T>,
17803    ) -> ::core::result::Result<
17804        (),
17805        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17806    > {
17807        match *message.header().ordinal {
17808            7992130864415541162 => {
17809                let responder = ::fidl_next::Responder::from_untyped(responder);
17810
17811                match ::fidl_next::AsDecoderExt::into_decoded(message) {
17812                    Ok(decoded) => {
17813                        handler
17814                            .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17815                            .await;
17816                        Ok(())
17817                    }
17818                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17819                        ordinal: 7992130864415541162,
17820                        error,
17821                    }),
17822                }
17823            }
17824
17825            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17826        }
17827    }
17828}
17829
17830/// A client handler for the AdvisoryLocking protocol.
17831///
17832/// See [`AdvisoryLocking`] for more details.
17833pub trait AdvisoryLockingClientHandler<
17834    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17835    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17836>
17837{
17838}
17839
17840impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for AdvisoryLocking
17841where
17842    ___H: AdvisoryLockingClientHandler<___T> + ::core::marker::Send,
17843    ___T: ::fidl_next::Transport,
17844{
17845    async fn on_event(
17846        handler: &mut ___H,
17847        mut message: ::fidl_next::Message<___T>,
17848    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17849        match *message.header().ordinal {
17850            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17851        }
17852    }
17853}
17854
17855/// A server handler for the AdvisoryLocking protocol.
17856///
17857/// See [`AdvisoryLocking`] for more details.
17858pub trait AdvisoryLockingServerHandler<
17859    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17860    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17861>
17862{
17863    #[doc = " Acquires an advisory lock on the underlying file.\n\n The lock lasts until either this connection is closed or\n this method is called with |AdvisoryLockType.UNLOCK| to release the lock\n explicitly.\n\n Advisory locks are purely advisory. They do not prevent actual read or\n write operations from occurring on the file, either through this\n connection or through other connections.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `request.type` is [`AdvisoryLockType.READ`].\n * [`Rights.WRITE_BYTES`] if `request.type` is\n   [`AdvisoryLockType.WRITE`].\n\n # Errors\n\n * `ZX_ERR_BAD_STATE` The specified type of lock cannot be acquired. For\n   example, another connection might hold a conflicting lock type.\n * `ZX_ERR_NOT_SUPPORTED` This file does not support advisory locking.\n * `ZX_ERR_ACCESS_DENIED` This connection does not have sufficient rights\n   to acquire the given type of lock.\n"]
17864    fn advisory_lock(
17865        &mut self,
17866
17867        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17868
17869        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17870    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17871}
17872
17873impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for AdvisoryLocking
17874where
17875    ___H: AdvisoryLockingServerHandler<___T> + ::core::marker::Send,
17876    ___T: ::fidl_next::Transport,
17877    for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
17878            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17879            Constraint = (),
17880        >,
17881{
17882    async fn on_one_way(
17883        handler: &mut ___H,
17884        mut message: ::fidl_next::Message<___T>,
17885    ) -> ::core::result::Result<
17886        (),
17887        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17888    > {
17889        match *message.header().ordinal {
17890            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17891        }
17892    }
17893
17894    async fn on_two_way(
17895        handler: &mut ___H,
17896        mut message: ::fidl_next::Message<___T>,
17897        responder: ::fidl_next::protocol::Responder<___T>,
17898    ) -> ::core::result::Result<
17899        (),
17900        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17901    > {
17902        match *message.header().ordinal {
17903            7992130864415541162 => {
17904                let responder = ::fidl_next::Responder::from_untyped(responder);
17905
17906                match ::fidl_next::AsDecoderExt::into_decoded(message) {
17907                    Ok(decoded) => {
17908                        handler
17909                            .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17910                            .await;
17911                        Ok(())
17912                    }
17913                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17914                        ordinal: 7992130864415541162,
17915                        error,
17916                    }),
17917                }
17918            }
17919
17920            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17921        }
17922    }
17923}
17924
17925impl<___T> AdvisoryLockingClientHandler<___T> for ::fidl_next::IgnoreEvents where
17926    ___T: ::fidl_next::Transport
17927{
17928}
17929
17930impl<___H, ___T> AdvisoryLockingLocalClientHandler<___T> for ::fidl_next::Local<___H>
17931where
17932    ___H: AdvisoryLockingClientHandler<___T>,
17933    ___T: ::fidl_next::Transport,
17934{
17935}
17936
17937impl<___H, ___T> AdvisoryLockingLocalServerHandler<___T> for ::fidl_next::Local<___H>
17938where
17939    ___H: AdvisoryLockingServerHandler<___T>,
17940    ___T: ::fidl_next::Transport,
17941{
17942    async fn advisory_lock(
17943        &mut self,
17944
17945        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17946
17947        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17948    ) {
17949        ___H::advisory_lock(&mut self.0, request, responder).await
17950    }
17951}
17952
17953pub const DIRECTORY_PROTOCOL_NAME: &str = "fuchsia.io/Directory";
17954
17955#[doc = " The maximum length, in bytes, of a filesystem path.\n"]
17956pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
17957
17958#[doc = " The maximal buffer size which can be transmitted for buffered operations.\n This capacity is currently set somewhat arbitrarily.\n"]
17959pub const MAX_BUF: u64 = 8192 as u64;
17960
17961#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
17962pub const MAX_NAME_LENGTH: u64 = 255 as u64;
17963
17964#[doc = " The maximum size for an extended attribute name.\n"]
17965pub const MAX_ATTRIBUTE_NAME: u64 = 255 as u64;
17966
17967#[doc = " The maximum size for an extended attribute value to be included inline.\n Values larger than this size are passed in a vmo.\n"]
17968pub const MAX_INLINE_ATTRIBUTE_VALUE: u64 = 32768 as u64;
17969
17970#[doc = " The maximum size for passing the SELinux context as an attribute.\n"]
17971pub const MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN: u64 = 256 as u64;
17972
17973/// The type corresponding to the DirectoryWatcher protocol.
17974#[doc = " DirectoryWatcher transmits messages from a filesystem server\n about events happening in the filesystem. Clients can register\n new watchers using the `Directory.Watch` method, where they can\n filter which events they want to receive notifications for.\n\n The DirectoryWatcher will send messages of the form:\n ```\n struct {\n   uint8 event;\n   uint8 len;\n   char name[];\n };\n ```\n Where names are NOT null-terminated. The name is the relative\n path to the entry the event is refering to. It will be empty if\n the event isn\'t referencing a particular entry (e.g. for the\n `IDLE` event).\n"]
17975#[derive(PartialEq, Debug)]
17976pub struct DirectoryWatcher;
17977
17978#[cfg(target_os = "fuchsia")]
17979impl ::fidl_next::HasTransport for DirectoryWatcher {
17980    type Transport = ::fidl_next::fuchsia::zx::Channel;
17981}
17982
17983pub mod directory_watcher {
17984    pub mod prelude {
17985        pub use crate::{
17986            DirectoryWatcher, DirectoryWatcherClientHandler, DirectoryWatcherLocalClientHandler,
17987            DirectoryWatcherLocalServerHandler, DirectoryWatcherServerHandler, directory_watcher,
17988        };
17989    }
17990
17991    mod ___detail {
17992        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryWatcher
17993        where
17994            ___T: ::fidl_next::Transport,
17995        {
17996            type Client = DirectoryWatcherClient<___T>;
17997            type Server = DirectoryWatcherServer<___T>;
17998        }
17999
18000        /// The client for the `DirectoryWatcher` protocol.
18001        #[repr(transparent)]
18002        pub struct DirectoryWatcherClient<___T: ::fidl_next::Transport> {
18003            #[allow(dead_code)]
18004            client: ::fidl_next::protocol::Client<___T>,
18005        }
18006
18007        impl<___T> DirectoryWatcherClient<___T> where ___T: ::fidl_next::Transport {}
18008
18009        /// The server for the `DirectoryWatcher` protocol.
18010        #[repr(transparent)]
18011        pub struct DirectoryWatcherServer<___T: ::fidl_next::Transport> {
18012            server: ::fidl_next::protocol::Server<___T>,
18013        }
18014
18015        impl<___T> DirectoryWatcherServer<___T> where ___T: ::fidl_next::Transport {}
18016    }
18017}
18018
18019#[diagnostic::on_unimplemented(
18020    note = "If {Self} implements the non-local DirectoryWatcherClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18021)]
18022
18023/// A client handler for the DirectoryWatcher protocol.
18024///
18025/// See [`DirectoryWatcher`] for more details.
18026pub trait DirectoryWatcherLocalClientHandler<
18027    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18028    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18029>
18030{
18031}
18032
18033impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirectoryWatcher
18034where
18035    ___H: DirectoryWatcherLocalClientHandler<___T>,
18036    ___T: ::fidl_next::Transport,
18037{
18038    async fn on_event(
18039        handler: &mut ___H,
18040        mut message: ::fidl_next::Message<___T>,
18041    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18042        match *message.header().ordinal {
18043            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18044        }
18045    }
18046}
18047
18048#[diagnostic::on_unimplemented(
18049    note = "If {Self} implements the non-local DirectoryWatcherServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18050)]
18051
18052/// A server handler for the DirectoryWatcher protocol.
18053///
18054/// See [`DirectoryWatcher`] for more details.
18055pub trait DirectoryWatcherLocalServerHandler<
18056    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18057    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18058>
18059{
18060}
18061
18062impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirectoryWatcher
18063where
18064    ___H: DirectoryWatcherLocalServerHandler<___T>,
18065    ___T: ::fidl_next::Transport,
18066{
18067    async fn on_one_way(
18068        handler: &mut ___H,
18069        mut message: ::fidl_next::Message<___T>,
18070    ) -> ::core::result::Result<
18071        (),
18072        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18073    > {
18074        match *message.header().ordinal {
18075            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18076        }
18077    }
18078
18079    async fn on_two_way(
18080        handler: &mut ___H,
18081        mut message: ::fidl_next::Message<___T>,
18082        responder: ::fidl_next::protocol::Responder<___T>,
18083    ) -> ::core::result::Result<
18084        (),
18085        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18086    > {
18087        match *message.header().ordinal {
18088            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18089        }
18090    }
18091}
18092
18093/// A client handler for the DirectoryWatcher protocol.
18094///
18095/// See [`DirectoryWatcher`] for more details.
18096pub trait DirectoryWatcherClientHandler<
18097    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18098    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18099>
18100{
18101}
18102
18103impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryWatcher
18104where
18105    ___H: DirectoryWatcherClientHandler<___T> + ::core::marker::Send,
18106    ___T: ::fidl_next::Transport,
18107{
18108    async fn on_event(
18109        handler: &mut ___H,
18110        mut message: ::fidl_next::Message<___T>,
18111    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18112        match *message.header().ordinal {
18113            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18114        }
18115    }
18116}
18117
18118/// A server handler for the DirectoryWatcher protocol.
18119///
18120/// See [`DirectoryWatcher`] for more details.
18121pub trait DirectoryWatcherServerHandler<
18122    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18123    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18124>
18125{
18126}
18127
18128impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryWatcher
18129where
18130    ___H: DirectoryWatcherServerHandler<___T> + ::core::marker::Send,
18131    ___T: ::fidl_next::Transport,
18132{
18133    async fn on_one_way(
18134        handler: &mut ___H,
18135        mut message: ::fidl_next::Message<___T>,
18136    ) -> ::core::result::Result<
18137        (),
18138        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18139    > {
18140        match *message.header().ordinal {
18141            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18142        }
18143    }
18144
18145    async fn on_two_way(
18146        handler: &mut ___H,
18147        mut message: ::fidl_next::Message<___T>,
18148        responder: ::fidl_next::protocol::Responder<___T>,
18149    ) -> ::core::result::Result<
18150        (),
18151        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18152    > {
18153        match *message.header().ordinal {
18154            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18155        }
18156    }
18157}
18158
18159impl<___T> DirectoryWatcherClientHandler<___T> for ::fidl_next::IgnoreEvents where
18160    ___T: ::fidl_next::Transport
18161{
18162}
18163
18164impl<___H, ___T> DirectoryWatcherLocalClientHandler<___T> for ::fidl_next::Local<___H>
18165where
18166    ___H: DirectoryWatcherClientHandler<___T>,
18167    ___T: ::fidl_next::Transport,
18168{
18169}
18170
18171impl<___H, ___T> DirectoryWatcherLocalServerHandler<___T> for ::fidl_next::Local<___H>
18172where
18173    ___H: DirectoryWatcherServerHandler<___T>,
18174    ___T: ::fidl_next::Transport,
18175{
18176}
18177
18178#[doc = " The maximum size of a chunk in the ListExtendedAttributes iterator.\n"]
18179pub const MAX_LIST_ATTRIBUTES_CHUNK: u64 = 128 as u64;
18180
18181/// The type corresponding to the ExtendedAttributeIterator protocol.
18182#[derive(PartialEq, Debug)]
18183pub struct ExtendedAttributeIterator;
18184
18185#[cfg(target_os = "fuchsia")]
18186impl ::fidl_next::HasTransport for ExtendedAttributeIterator {
18187    type Transport = ::fidl_next::fuchsia::zx::Channel;
18188}
18189
18190pub mod extended_attribute_iterator {
18191    pub mod prelude {
18192        pub use crate::{
18193            ExtendedAttributeIterator, ExtendedAttributeIteratorClientHandler,
18194            ExtendedAttributeIteratorLocalClientHandler,
18195            ExtendedAttributeIteratorLocalServerHandler, ExtendedAttributeIteratorServerHandler,
18196            extended_attribute_iterator,
18197        };
18198
18199        pub use crate::natural::ExtendedAttributeIteratorGetNextResponse;
18200    }
18201
18202    pub struct GetNext;
18203
18204    impl ::fidl_next::Method for GetNext {
18205        const ORDINAL: u64 = 268639596268373415;
18206        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18207            ::fidl_next::protocol::Flexibility::Strict;
18208
18209        type Protocol = crate::ExtendedAttributeIterator;
18210
18211        type Request = ::fidl_next::wire::EmptyMessageBody;
18212    }
18213
18214    impl ::fidl_next::TwoWayMethod for GetNext {
18215        type Response = ::fidl_next::wire::Result<
18216            'static,
18217            crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
18218            ::fidl_next::wire::fuchsia::Status,
18219        >;
18220    }
18221
18222    impl<___R> ::fidl_next::Respond<___R> for GetNext {
18223        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18224
18225        fn respond(response: ___R) -> Self::Output {
18226            ::core::result::Result::Ok(response)
18227        }
18228    }
18229
18230    impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
18231        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18232
18233        fn respond_err(response: ___R) -> Self::Output {
18234            ::core::result::Result::Err(response)
18235        }
18236    }
18237
18238    mod ___detail {
18239        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExtendedAttributeIterator
18240        where
18241            ___T: ::fidl_next::Transport,
18242        {
18243            type Client = ExtendedAttributeIteratorClient<___T>;
18244            type Server = ExtendedAttributeIteratorServer<___T>;
18245        }
18246
18247        /// The client for the `ExtendedAttributeIterator` protocol.
18248        #[repr(transparent)]
18249        pub struct ExtendedAttributeIteratorClient<___T: ::fidl_next::Transport> {
18250            #[allow(dead_code)]
18251            client: ::fidl_next::protocol::Client<___T>,
18252        }
18253
18254        impl<___T> ExtendedAttributeIteratorClient<___T>
18255        where
18256            ___T: ::fidl_next::Transport,
18257        {
18258            #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
18259            pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
18260                ::fidl_next::TwoWayFuture::from_untyped(
18261                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18262                        268639596268373415,
18263                        <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
18264                        (),
18265                    ),
18266                )
18267            }
18268        }
18269
18270        /// The server for the `ExtendedAttributeIterator` protocol.
18271        #[repr(transparent)]
18272        pub struct ExtendedAttributeIteratorServer<___T: ::fidl_next::Transport> {
18273            server: ::fidl_next::protocol::Server<___T>,
18274        }
18275
18276        impl<___T> ExtendedAttributeIteratorServer<___T> where ___T: ::fidl_next::Transport {}
18277    }
18278}
18279
18280#[diagnostic::on_unimplemented(
18281    note = "If {Self} implements the non-local ExtendedAttributeIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18282)]
18283
18284/// A client handler for the ExtendedAttributeIterator protocol.
18285///
18286/// See [`ExtendedAttributeIterator`] for more details.
18287pub trait ExtendedAttributeIteratorLocalClientHandler<
18288    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18289    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18290>
18291{
18292}
18293
18294impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExtendedAttributeIterator
18295where
18296    ___H: ExtendedAttributeIteratorLocalClientHandler<___T>,
18297    ___T: ::fidl_next::Transport,
18298{
18299    async fn on_event(
18300        handler: &mut ___H,
18301        mut message: ::fidl_next::Message<___T>,
18302    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18303        match *message.header().ordinal {
18304            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18305        }
18306    }
18307}
18308
18309#[diagnostic::on_unimplemented(
18310    note = "If {Self} implements the non-local ExtendedAttributeIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18311)]
18312
18313/// A server handler for the ExtendedAttributeIterator protocol.
18314///
18315/// See [`ExtendedAttributeIterator`] for more details.
18316pub trait ExtendedAttributeIteratorLocalServerHandler<
18317    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18318    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18319>
18320{
18321    #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
18322    fn get_next(
18323        &mut self,
18324
18325        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18326    ) -> impl ::core::future::Future<Output = ()>;
18327}
18328
18329impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExtendedAttributeIterator
18330where
18331    ___H: ExtendedAttributeIteratorLocalServerHandler<___T>,
18332    ___T: ::fidl_next::Transport,
18333{
18334    async fn on_one_way(
18335        handler: &mut ___H,
18336        mut message: ::fidl_next::Message<___T>,
18337    ) -> ::core::result::Result<
18338        (),
18339        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18340    > {
18341        match *message.header().ordinal {
18342            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18343        }
18344    }
18345
18346    async fn on_two_way(
18347        handler: &mut ___H,
18348        mut message: ::fidl_next::Message<___T>,
18349        responder: ::fidl_next::protocol::Responder<___T>,
18350    ) -> ::core::result::Result<
18351        (),
18352        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18353    > {
18354        match *message.header().ordinal {
18355            268639596268373415 => {
18356                let responder = ::fidl_next::Responder::from_untyped(responder);
18357
18358                handler.get_next(responder).await;
18359                Ok(())
18360            }
18361
18362            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18363        }
18364    }
18365}
18366
18367/// A client handler for the ExtendedAttributeIterator protocol.
18368///
18369/// See [`ExtendedAttributeIterator`] for more details.
18370pub trait ExtendedAttributeIteratorClientHandler<
18371    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18372    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18373>
18374{
18375}
18376
18377impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExtendedAttributeIterator
18378where
18379    ___H: ExtendedAttributeIteratorClientHandler<___T> + ::core::marker::Send,
18380    ___T: ::fidl_next::Transport,
18381{
18382    async fn on_event(
18383        handler: &mut ___H,
18384        mut message: ::fidl_next::Message<___T>,
18385    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18386        match *message.header().ordinal {
18387            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18388        }
18389    }
18390}
18391
18392/// A server handler for the ExtendedAttributeIterator protocol.
18393///
18394/// See [`ExtendedAttributeIterator`] for more details.
18395pub trait ExtendedAttributeIteratorServerHandler<
18396    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18397    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18398>
18399{
18400    #[doc = " Get the next chunk of extended attribute names. If this is the last\n chunk, last will be true, and the channel will be closed after the\n call.\n"]
18401    fn get_next(
18402        &mut self,
18403
18404        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18405    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18406}
18407
18408impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExtendedAttributeIterator
18409where
18410    ___H: ExtendedAttributeIteratorServerHandler<___T> + ::core::marker::Send,
18411    ___T: ::fidl_next::Transport,
18412{
18413    async fn on_one_way(
18414        handler: &mut ___H,
18415        mut message: ::fidl_next::Message<___T>,
18416    ) -> ::core::result::Result<
18417        (),
18418        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18419    > {
18420        match *message.header().ordinal {
18421            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18422        }
18423    }
18424
18425    async fn on_two_way(
18426        handler: &mut ___H,
18427        mut message: ::fidl_next::Message<___T>,
18428        responder: ::fidl_next::protocol::Responder<___T>,
18429    ) -> ::core::result::Result<
18430        (),
18431        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18432    > {
18433        match *message.header().ordinal {
18434            268639596268373415 => {
18435                let responder = ::fidl_next::Responder::from_untyped(responder);
18436
18437                handler.get_next(responder).await;
18438                Ok(())
18439            }
18440
18441            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18442        }
18443    }
18444}
18445
18446impl<___T> ExtendedAttributeIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
18447    ___T: ::fidl_next::Transport
18448{
18449}
18450
18451impl<___H, ___T> ExtendedAttributeIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
18452where
18453    ___H: ExtendedAttributeIteratorClientHandler<___T>,
18454    ___T: ::fidl_next::Transport,
18455{
18456}
18457
18458impl<___H, ___T> ExtendedAttributeIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
18459where
18460    ___H: ExtendedAttributeIteratorServerHandler<___T>,
18461    ___T: ::fidl_next::Transport,
18462{
18463    async fn get_next(
18464        &mut self,
18465
18466        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18467    ) {
18468        ___H::get_next(&mut self.0, responder).await
18469    }
18470}
18471
18472pub const FILE_PROTOCOL_NAME: &str = "fuchsia.io/File";
18473
18474#[doc = " Specifies that this object is not linkable. This is only intended to be used in the context of\n creating a temporary unnamed objects. When that is not the case, the node protocol defines if it\n is linkable (i.e. if it composes the `Linkable` protocol). When this flag is set along with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`, an unnamed temporary object will be created that\n cannot be linked into the filesystem. This would be similar to Linux `O_TMPFILE | O_EXCL`.\n\n CAUTION: if `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY` is not specified,  then this is treated as\n a \"must create\" flag.\n\n The reason for overloading `Flags.FLAG_MUST_CREATE` to mean \"not linkable\" in this context and\n \"must create\" in other contexts is due to the assumption that some POSIX flags are compatible\n with the members in `Flags`. In particular the POSIX `O_EXCL` has the same value as\n `Flags.FLAG_MUST_CREATE`. We are not able to define different bit members of the same value,\n hence it is defined separately outside of `Flags`.\n"]
18475pub const FLAG_TEMPORARY_AS_NOT_LINKABLE: crate::natural::Flags =
18476    crate::natural::Flags::FLAG_MUST_CREATE;
18477
18478#[doc = " The maximum I/O size that is allowed for read/write operations using\n byte vectors.\n"]
18479pub const MAX_TRANSFER_SIZE: u64 = 8192 as u64;
18480
18481/// The type corresponding to the Readable protocol.
18482#[derive(PartialEq, Debug)]
18483pub struct Readable;
18484
18485#[cfg(target_os = "fuchsia")]
18486impl ::fidl_next::HasTransport for Readable {
18487    type Transport = ::fidl_next::fuchsia::zx::Channel;
18488}
18489
18490pub mod readable {
18491    pub mod prelude {
18492        pub use crate::{
18493            Readable, ReadableClientHandler, ReadableLocalClientHandler,
18494            ReadableLocalServerHandler, ReadableServerHandler, readable,
18495        };
18496
18497        pub use crate::natural::ReadableReadRequest;
18498
18499        pub use crate::natural::ReadableReadResponse;
18500    }
18501
18502    pub struct Read;
18503
18504    impl ::fidl_next::Method for Read {
18505        const ORDINAL: u64 = 395825947633028830;
18506        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18507            ::fidl_next::protocol::Flexibility::Strict;
18508
18509        type Protocol = crate::Readable;
18510
18511        type Request = crate::wire::ReadableReadRequest;
18512    }
18513
18514    impl ::fidl_next::TwoWayMethod for Read {
18515        type Response = ::fidl_next::wire::Result<
18516            'static,
18517            crate::wire::ReadableReadResponse<'static>,
18518            ::fidl_next::wire::fuchsia::Status,
18519        >;
18520    }
18521
18522    impl<___R> ::fidl_next::Respond<___R> for Read {
18523        type Output = ::core::result::Result<
18524            crate::generic::ReadableReadResponse<___R>,
18525            ::fidl_next::never::Never,
18526        >;
18527
18528        fn respond(response: ___R) -> Self::Output {
18529            ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
18530        }
18531    }
18532
18533    impl<___R> ::fidl_next::RespondErr<___R> for Read {
18534        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18535
18536        fn respond_err(response: ___R) -> Self::Output {
18537            ::core::result::Result::Err(response)
18538        }
18539    }
18540
18541    mod ___detail {
18542        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Readable
18543        where
18544            ___T: ::fidl_next::Transport,
18545        {
18546            type Client = ReadableClient<___T>;
18547            type Server = ReadableServer<___T>;
18548        }
18549
18550        /// The client for the `Readable` protocol.
18551        #[repr(transparent)]
18552        pub struct ReadableClient<___T: ::fidl_next::Transport> {
18553            #[allow(dead_code)]
18554            client: ::fidl_next::protocol::Client<___T>,
18555        }
18556
18557        impl<___T> ReadableClient<___T>
18558        where
18559            ___T: ::fidl_next::Transport,
18560        {
18561            #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
18562            pub fn read(
18563                &self,
18564
18565                count: impl ::fidl_next::Encode<
18566                    ::fidl_next::wire::Uint64,
18567                    <___T as ::fidl_next::Transport>::SendBuffer,
18568                >,
18569            ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
18570            where
18571                <___T as ::fidl_next::Transport>::SendBuffer:
18572                    ::fidl_next::encoder::InternalHandleEncoder,
18573            {
18574                self.read_with(crate::generic::ReadableReadRequest { count })
18575            }
18576
18577            #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
18578            pub fn read_with<___R>(
18579                &self,
18580                request: ___R,
18581            ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
18582            where
18583                ___R: ::fidl_next::Encode<
18584                        crate::wire::ReadableReadRequest,
18585                        <___T as ::fidl_next::Transport>::SendBuffer,
18586                    >,
18587            {
18588                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18589                    395825947633028830,
18590                    <super::Read as ::fidl_next::Method>::FLEXIBILITY,
18591                    request,
18592                ))
18593            }
18594        }
18595
18596        /// The server for the `Readable` protocol.
18597        #[repr(transparent)]
18598        pub struct ReadableServer<___T: ::fidl_next::Transport> {
18599            server: ::fidl_next::protocol::Server<___T>,
18600        }
18601
18602        impl<___T> ReadableServer<___T> where ___T: ::fidl_next::Transport {}
18603    }
18604}
18605
18606#[diagnostic::on_unimplemented(
18607    note = "If {Self} implements the non-local ReadableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18608)]
18609
18610/// A client handler for the Readable protocol.
18611///
18612/// See [`Readable`] for more details.
18613pub trait ReadableLocalClientHandler<
18614    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18615    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18616>
18617{
18618}
18619
18620impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Readable
18621where
18622    ___H: ReadableLocalClientHandler<___T>,
18623    ___T: ::fidl_next::Transport,
18624{
18625    async fn on_event(
18626        handler: &mut ___H,
18627        mut message: ::fidl_next::Message<___T>,
18628    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18629        match *message.header().ordinal {
18630            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18631        }
18632    }
18633}
18634
18635#[diagnostic::on_unimplemented(
18636    note = "If {Self} implements the non-local ReadableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18637)]
18638
18639/// A server handler for the Readable protocol.
18640///
18641/// See [`Readable`] for more details.
18642pub trait ReadableLocalServerHandler<
18643    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18644    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18645>
18646{
18647    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
18648    fn read(
18649        &mut self,
18650
18651        request: ::fidl_next::Request<readable::Read, ___T>,
18652
18653        responder: ::fidl_next::Responder<readable::Read, ___T>,
18654    ) -> impl ::core::future::Future<Output = ()>;
18655}
18656
18657impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Readable
18658where
18659    ___H: ReadableLocalServerHandler<___T>,
18660    ___T: ::fidl_next::Transport,
18661    for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
18662            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18663            Constraint = (),
18664        >,
18665{
18666    async fn on_one_way(
18667        handler: &mut ___H,
18668        mut message: ::fidl_next::Message<___T>,
18669    ) -> ::core::result::Result<
18670        (),
18671        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18672    > {
18673        match *message.header().ordinal {
18674            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18675        }
18676    }
18677
18678    async fn on_two_way(
18679        handler: &mut ___H,
18680        mut message: ::fidl_next::Message<___T>,
18681        responder: ::fidl_next::protocol::Responder<___T>,
18682    ) -> ::core::result::Result<
18683        (),
18684        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18685    > {
18686        match *message.header().ordinal {
18687            395825947633028830 => {
18688                let responder = ::fidl_next::Responder::from_untyped(responder);
18689
18690                match ::fidl_next::AsDecoderExt::into_decoded(message) {
18691                    Ok(decoded) => {
18692                        handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
18693                        Ok(())
18694                    }
18695                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18696                        ordinal: 395825947633028830,
18697                        error,
18698                    }),
18699                }
18700            }
18701
18702            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18703        }
18704    }
18705}
18706
18707/// A client handler for the Readable protocol.
18708///
18709/// See [`Readable`] for more details.
18710pub trait ReadableClientHandler<
18711    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18712    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18713>
18714{
18715}
18716
18717impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Readable
18718where
18719    ___H: ReadableClientHandler<___T> + ::core::marker::Send,
18720    ___T: ::fidl_next::Transport,
18721{
18722    async fn on_event(
18723        handler: &mut ___H,
18724        mut message: ::fidl_next::Message<___T>,
18725    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18726        match *message.header().ordinal {
18727            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18728        }
18729    }
18730}
18731
18732/// A server handler for the Readable protocol.
18733///
18734/// See [`Readable`] for more details.
18735pub trait ReadableServerHandler<
18736    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18737    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18738>
18739{
18740    #[doc = " Reads up to \'count\' bytes at the seek offset.\n The seek offset is moved forward by the number of bytes read.\n\n ## Invariants\n\n * The returned `data.length` will never be greater than `count`.\n * If `data.length` is less than `count`, it means that the seek offset\n   has reached the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that the\n   seek offset is already at or beyond the end of file, and no data could\n   be read.\n * If `count` is zero, the server should perform all the checks ensuring\n   read access without actually read anything, and return an empty\n   `data` vector.\n\n This method requires the [`Rights.READ_BYTES`] right.\n\n Returns `ZX_ERR_OUT_OF_RANGE` if `count` is greater than `MAX_TRANSFER_SIZE`.\n"]
18741    fn read(
18742        &mut self,
18743
18744        request: ::fidl_next::Request<readable::Read, ___T>,
18745
18746        responder: ::fidl_next::Responder<readable::Read, ___T>,
18747    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18748}
18749
18750impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Readable
18751where
18752    ___H: ReadableServerHandler<___T> + ::core::marker::Send,
18753    ___T: ::fidl_next::Transport,
18754    for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
18755            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18756            Constraint = (),
18757        >,
18758{
18759    async fn on_one_way(
18760        handler: &mut ___H,
18761        mut message: ::fidl_next::Message<___T>,
18762    ) -> ::core::result::Result<
18763        (),
18764        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18765    > {
18766        match *message.header().ordinal {
18767            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18768        }
18769    }
18770
18771    async fn on_two_way(
18772        handler: &mut ___H,
18773        mut message: ::fidl_next::Message<___T>,
18774        responder: ::fidl_next::protocol::Responder<___T>,
18775    ) -> ::core::result::Result<
18776        (),
18777        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18778    > {
18779        match *message.header().ordinal {
18780            395825947633028830 => {
18781                let responder = ::fidl_next::Responder::from_untyped(responder);
18782
18783                match ::fidl_next::AsDecoderExt::into_decoded(message) {
18784                    Ok(decoded) => {
18785                        handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
18786                        Ok(())
18787                    }
18788                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18789                        ordinal: 395825947633028830,
18790                        error,
18791                    }),
18792                }
18793            }
18794
18795            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18796        }
18797    }
18798}
18799
18800impl<___T> ReadableClientHandler<___T> for ::fidl_next::IgnoreEvents where
18801    ___T: ::fidl_next::Transport
18802{
18803}
18804
18805impl<___H, ___T> ReadableLocalClientHandler<___T> for ::fidl_next::Local<___H>
18806where
18807    ___H: ReadableClientHandler<___T>,
18808    ___T: ::fidl_next::Transport,
18809{
18810}
18811
18812impl<___H, ___T> ReadableLocalServerHandler<___T> for ::fidl_next::Local<___H>
18813where
18814    ___H: ReadableServerHandler<___T>,
18815    ___T: ::fidl_next::Transport,
18816{
18817    async fn read(
18818        &mut self,
18819
18820        request: ::fidl_next::Request<readable::Read, ___T>,
18821
18822        responder: ::fidl_next::Responder<readable::Read, ___T>,
18823    ) {
18824        ___H::read(&mut self.0, request, responder).await
18825    }
18826}
18827
18828/// The type corresponding to the Writable protocol.
18829#[derive(PartialEq, Debug)]
18830pub struct Writable;
18831
18832#[cfg(target_os = "fuchsia")]
18833impl ::fidl_next::HasTransport for Writable {
18834    type Transport = ::fidl_next::fuchsia::zx::Channel;
18835}
18836
18837pub mod writable {
18838    pub mod prelude {
18839        pub use crate::{
18840            Writable, WritableClientHandler, WritableLocalClientHandler,
18841            WritableLocalServerHandler, WritableServerHandler, writable,
18842        };
18843
18844        pub use crate::natural::WritableWriteRequest;
18845
18846        pub use crate::natural::WritableWriteResponse;
18847    }
18848
18849    pub struct Write;
18850
18851    impl ::fidl_next::Method for Write {
18852        const ORDINAL: u64 = 7651971425397809026;
18853        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18854            ::fidl_next::protocol::Flexibility::Strict;
18855
18856        type Protocol = crate::Writable;
18857
18858        type Request = crate::wire::WritableWriteRequest<'static>;
18859    }
18860
18861    impl ::fidl_next::TwoWayMethod for Write {
18862        type Response = ::fidl_next::wire::Result<
18863            'static,
18864            crate::wire::WritableWriteResponse,
18865            ::fidl_next::wire::fuchsia::Status,
18866        >;
18867    }
18868
18869    impl<___R> ::fidl_next::Respond<___R> for Write {
18870        type Output = ::core::result::Result<
18871            crate::generic::WritableWriteResponse<___R>,
18872            ::fidl_next::never::Never,
18873        >;
18874
18875        fn respond(response: ___R) -> Self::Output {
18876            ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
18877                actual_count: response,
18878            })
18879        }
18880    }
18881
18882    impl<___R> ::fidl_next::RespondErr<___R> for Write {
18883        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18884
18885        fn respond_err(response: ___R) -> Self::Output {
18886            ::core::result::Result::Err(response)
18887        }
18888    }
18889
18890    mod ___detail {
18891        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Writable
18892        where
18893            ___T: ::fidl_next::Transport,
18894        {
18895            type Client = WritableClient<___T>;
18896            type Server = WritableServer<___T>;
18897        }
18898
18899        /// The client for the `Writable` protocol.
18900        #[repr(transparent)]
18901        pub struct WritableClient<___T: ::fidl_next::Transport> {
18902            #[allow(dead_code)]
18903            client: ::fidl_next::protocol::Client<___T>,
18904        }
18905
18906        impl<___T> WritableClient<___T>
18907        where
18908            ___T: ::fidl_next::Transport,
18909        {
18910            #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18911            pub fn write(
18912                &self,
18913
18914                data: impl ::fidl_next::Encode<
18915                    ::fidl_next::wire::Vector<'static, u8>,
18916                    <___T as ::fidl_next::Transport>::SendBuffer,
18917                >,
18918            ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
18919            where
18920                <___T as ::fidl_next::Transport>::SendBuffer:
18921                    ::fidl_next::encoder::InternalHandleEncoder,
18922                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18923            {
18924                self.write_with(crate::generic::WritableWriteRequest { data })
18925            }
18926
18927            #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18928            pub fn write_with<___R>(
18929                &self,
18930                request: ___R,
18931            ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
18932            where
18933                ___R: ::fidl_next::Encode<
18934                        crate::wire::WritableWriteRequest<'static>,
18935                        <___T as ::fidl_next::Transport>::SendBuffer,
18936                    >,
18937            {
18938                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18939                    7651971425397809026,
18940                    <super::Write as ::fidl_next::Method>::FLEXIBILITY,
18941                    request,
18942                ))
18943            }
18944        }
18945
18946        /// The server for the `Writable` protocol.
18947        #[repr(transparent)]
18948        pub struct WritableServer<___T: ::fidl_next::Transport> {
18949            server: ::fidl_next::protocol::Server<___T>,
18950        }
18951
18952        impl<___T> WritableServer<___T> where ___T: ::fidl_next::Transport {}
18953    }
18954}
18955
18956#[diagnostic::on_unimplemented(
18957    note = "If {Self} implements the non-local WritableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18958)]
18959
18960/// A client handler for the Writable protocol.
18961///
18962/// See [`Writable`] for more details.
18963pub trait WritableLocalClientHandler<
18964    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18965    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18966>
18967{
18968}
18969
18970impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Writable
18971where
18972    ___H: WritableLocalClientHandler<___T>,
18973    ___T: ::fidl_next::Transport,
18974{
18975    async fn on_event(
18976        handler: &mut ___H,
18977        mut message: ::fidl_next::Message<___T>,
18978    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18979        match *message.header().ordinal {
18980            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18981        }
18982    }
18983}
18984
18985#[diagnostic::on_unimplemented(
18986    note = "If {Self} implements the non-local WritableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18987)]
18988
18989/// A server handler for the Writable protocol.
18990///
18991/// See [`Writable`] for more details.
18992pub trait WritableLocalServerHandler<
18993    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18994    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18995>
18996{
18997    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18998    fn write(
18999        &mut self,
19000
19001        request: ::fidl_next::Request<writable::Write, ___T>,
19002
19003        responder: ::fidl_next::Responder<writable::Write, ___T>,
19004    ) -> impl ::core::future::Future<Output = ()>;
19005}
19006
19007impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Writable
19008where
19009    ___H: WritableLocalServerHandler<___T>,
19010    ___T: ::fidl_next::Transport,
19011    for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
19012            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19013            Constraint = (),
19014        >,
19015{
19016    async fn on_one_way(
19017        handler: &mut ___H,
19018        mut message: ::fidl_next::Message<___T>,
19019    ) -> ::core::result::Result<
19020        (),
19021        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19022    > {
19023        match *message.header().ordinal {
19024            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19025        }
19026    }
19027
19028    async fn on_two_way(
19029        handler: &mut ___H,
19030        mut message: ::fidl_next::Message<___T>,
19031        responder: ::fidl_next::protocol::Responder<___T>,
19032    ) -> ::core::result::Result<
19033        (),
19034        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19035    > {
19036        match *message.header().ordinal {
19037            7651971425397809026 => {
19038                let responder = ::fidl_next::Responder::from_untyped(responder);
19039
19040                match ::fidl_next::AsDecoderExt::into_decoded(message) {
19041                    Ok(decoded) => {
19042                        handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
19043                        Ok(())
19044                    }
19045                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19046                        ordinal: 7651971425397809026,
19047                        error,
19048                    }),
19049                }
19050            }
19051
19052            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19053        }
19054    }
19055}
19056
19057/// A client handler for the Writable protocol.
19058///
19059/// See [`Writable`] for more details.
19060pub trait WritableClientHandler<
19061    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19062    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19063>
19064{
19065}
19066
19067impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Writable
19068where
19069    ___H: WritableClientHandler<___T> + ::core::marker::Send,
19070    ___T: ::fidl_next::Transport,
19071{
19072    async fn on_event(
19073        handler: &mut ___H,
19074        mut message: ::fidl_next::Message<___T>,
19075    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19076        match *message.header().ordinal {
19077            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19078        }
19079    }
19080}
19081
19082/// A server handler for the Writable protocol.
19083///
19084/// See [`Writable`] for more details.
19085pub trait WritableServerHandler<
19086    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19087    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19088>
19089{
19090    #[doc = " Writes data at the seek offset.\n The seek offset is moved forward by the number of bytes written.\n If the file is in append mode, the seek offset is first set to the end\n of the file, followed by the write, in one atomic step.\n\n The file size may grow if the seek offset plus `data.length` is beyond\n the current end of file.\n\n + request `data` the byte buffer to write to the file.\n - response `actual_count` the number of bytes written.\n\n ## Invariants\n\n * The returned `actual_count` will never be greater than `data.length`.\n * If the server is unable to write all the data due to e.g. not enough\n   space, `actual_count` may be less than `data.length`.  If no bytes\n   could be written, an error is returned.\n * If `data.length` is zero, the server should perform all the checks\n   ensuring write access without mutating the file and return a\n   successful write of zero bytes.  The seek offset is still updated if\n   in append mode.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
19091    fn write(
19092        &mut self,
19093
19094        request: ::fidl_next::Request<writable::Write, ___T>,
19095
19096        responder: ::fidl_next::Responder<writable::Write, ___T>,
19097    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19098}
19099
19100impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Writable
19101where
19102    ___H: WritableServerHandler<___T> + ::core::marker::Send,
19103    ___T: ::fidl_next::Transport,
19104    for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
19105            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19106            Constraint = (),
19107        >,
19108{
19109    async fn on_one_way(
19110        handler: &mut ___H,
19111        mut message: ::fidl_next::Message<___T>,
19112    ) -> ::core::result::Result<
19113        (),
19114        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19115    > {
19116        match *message.header().ordinal {
19117            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19118        }
19119    }
19120
19121    async fn on_two_way(
19122        handler: &mut ___H,
19123        mut message: ::fidl_next::Message<___T>,
19124        responder: ::fidl_next::protocol::Responder<___T>,
19125    ) -> ::core::result::Result<
19126        (),
19127        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19128    > {
19129        match *message.header().ordinal {
19130            7651971425397809026 => {
19131                let responder = ::fidl_next::Responder::from_untyped(responder);
19132
19133                match ::fidl_next::AsDecoderExt::into_decoded(message) {
19134                    Ok(decoded) => {
19135                        handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
19136                        Ok(())
19137                    }
19138                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19139                        ordinal: 7651971425397809026,
19140                        error,
19141                    }),
19142                }
19143            }
19144
19145            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19146        }
19147    }
19148}
19149
19150impl<___T> WritableClientHandler<___T> for ::fidl_next::IgnoreEvents where
19151    ___T: ::fidl_next::Transport
19152{
19153}
19154
19155impl<___H, ___T> WritableLocalClientHandler<___T> for ::fidl_next::Local<___H>
19156where
19157    ___H: WritableClientHandler<___T>,
19158    ___T: ::fidl_next::Transport,
19159{
19160}
19161
19162impl<___H, ___T> WritableLocalServerHandler<___T> for ::fidl_next::Local<___H>
19163where
19164    ___H: WritableServerHandler<___T>,
19165    ___T: ::fidl_next::Transport,
19166{
19167    async fn write(
19168        &mut self,
19169
19170        request: ::fidl_next::Request<writable::Write, ___T>,
19171
19172        responder: ::fidl_next::Responder<writable::Write, ___T>,
19173    ) {
19174        ___H::write(&mut self.0, request, responder).await
19175    }
19176}
19177
19178pub const MAX_FS_NAME_BUFFER: u64 = 32 as u64;
19179
19180#[doc = " Set of rights that [`Flags.PERM_INHERIT_WRITE`] will inherit from the parent connection if\n specified. Note that if any of these permissions are missing from the connection, none of these\n permissions will be inherited.\n"]
19181pub const INHERITED_WRITE_PERMISSIONS: crate::natural::Operations =
19182    crate::natural::Operations::from_bits_retain(356);
19183
19184#[doc = " Nodes which do not have ino values should return this value\n from Readdir and GetAttr.\n"]
19185pub const INO_UNKNOWN: u64 = 18446744073709551615 as u64;
19186
19187pub const MASK_KNOWN_PERMISSIONS: crate::natural::Flags =
19188    crate::natural::Flags::from_bits_retain(25087);
19189
19190pub const MASK_KNOWN_PROTOCOLS: crate::natural::Flags =
19191    crate::natural::Flags::from_bits_retain(30069489664);
19192
19193pub const MASK_PERMISSION_FLAGS: u64 = 65535 as u64;
19194
19195pub const MASK_POSIX_FLAGS: u64 = 4294967295 as u64;
19196
19197#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
19198pub const MAX_FILENAME: u64 = 255 as u64;
19199
19200pub const NODE_PROTOCOL_NAME: &str = "fuchsia.io/Node";
19201
19202#[doc = " Flags used when opening a node reference must fall within this mask.\n"]
19203pub const OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE: crate::natural::OpenFlags =
19204    crate::natural::OpenFlags::from_bits_retain(46661632);
19205
19206#[doc = " All known rights.\n"]
19207pub const OPEN_RIGHTS: crate::natural::OpenFlags = crate::natural::OpenFlags::from_bits_retain(11);
19208
19209#[doc = " Set of permissions that are expected when opening a node as executable.\n"]
19210pub const PERM_EXECUTABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(201);
19211
19212#[doc = " Set of permissions that are expected when opening a node as readable.\n"]
19213pub const PERM_READABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(211);
19214
19215#[doc = " Set of permissions that are expected when opening a node as writable.\n"]
19216pub const PERM_WRITABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(485);
19217
19218#[doc = " Alias for directory permission alias rw*\n"]
19219pub const RW_STAR_DIR: crate::natural::Operations =
19220    crate::natural::Operations::from_bits_retain(503);
19221
19222#[doc = " Alias for directory permission alias rx*\n"]
19223pub const RX_STAR_DIR: crate::natural::Operations =
19224    crate::natural::Operations::from_bits_retain(219);
19225
19226#[doc = " Alias for directory permission alias r*\n"]
19227pub const R_STAR_DIR: crate::natural::Operations =
19228    crate::natural::Operations::from_bits_retain(211);
19229
19230#[doc = " The name of the extended attribute accessible via the SELinux context attribute.\n"]
19231pub const SELINUX_CONTEXT_NAME: &str = "security.selinux";
19232
19233pub const SYMLINK_PROTOCOL_NAME: &str = "fuchsia.io/Symlink";
19234
19235#[doc = " Alias for directory permission alias w*\n"]
19236pub const W_STAR_DIR: crate::natural::Operations =
19237    crate::natural::Operations::from_bits_retain(485);
19238
19239#[doc = " Alias for directory permission alias x*\n"]
19240pub const X_STAR_DIR: crate::natural::Operations =
19241    crate::natural::Operations::from_bits_retain(201);
fidl_next_common_fuchsia_io/fidl_next_common_fuchsia_io.rs

fidl_next_common_fuchsia_io/
fidl_next_common_fuchsia_io.rs
