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            const _ = !0;
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            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
51            Ok(())
52        }
53    }
54
55    impl ::core::convert::From<crate::wire::Operations> for Operations {
56        fn from(wire: crate::wire::Operations) -> Self {
57            Self::from_bits_retain(u64::from(wire.value))
58        }
59    }
60
61    impl ::fidl_next::FromWire<crate::wire::Operations> for Operations {
62        #[inline]
63        fn from_wire(wire: crate::wire::Operations) -> Self {
64            Self::from(wire)
65        }
66    }
67
68    impl ::fidl_next::FromWireRef<crate::wire::Operations> for Operations {
69        #[inline]
70        fn from_wire_ref(wire: &crate::wire::Operations) -> Self {
71            Self::from(*wire)
72        }
73    }
74
75    #[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"]
76    pub type Abilities = crate::natural::Operations;
77
78    #[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"]
79    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
80    #[repr(u32)]
81    pub enum SeekOrigin {
82        Start = 0,
83        Current = 1,
84        End = 2,
85    }
86    impl ::core::convert::TryFrom<u32> for SeekOrigin {
87        type Error = ::fidl_next::UnknownStrictEnumMemberError;
88        fn try_from(
89            value: u32,
90        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
91            match value {
92                0 => Ok(Self::Start),
93                1 => Ok(Self::Current),
94                2 => Ok(Self::End),
95
96                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
97            }
98        }
99    }
100
101    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for SeekOrigin
102    where
103        ___E: ?Sized,
104    {
105        #[inline]
106        fn encode(
107            self,
108            encoder: &mut ___E,
109            out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
110            _: (),
111        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
112            ::fidl_next::Encode::encode(&self, encoder, out, ())
113        }
114    }
115
116    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SeekOrigin, ___E> for &'a SeekOrigin
117    where
118        ___E: ?Sized,
119    {
120        #[inline]
121        fn encode(
122            self,
123            encoder: &mut ___E,
124            out: &mut ::core::mem::MaybeUninit<crate::wire::SeekOrigin>,
125            _: (),
126        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
127            ::fidl_next::munge!(let crate::wire::SeekOrigin { value } = out);
128            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
129                SeekOrigin::Start => 0,
130
131                SeekOrigin::Current => 1,
132
133                SeekOrigin::End => 2,
134            }));
135
136            Ok(())
137        }
138    }
139
140    impl ::core::convert::From<crate::wire::SeekOrigin> for SeekOrigin {
141        fn from(wire: crate::wire::SeekOrigin) -> Self {
142            match u32::from(wire.value) {
143                0 => Self::Start,
144
145                1 => Self::Current,
146
147                2 => Self::End,
148
149                _ => unsafe { ::core::hint::unreachable_unchecked() },
150            }
151        }
152    }
153
154    impl ::fidl_next::FromWire<crate::wire::SeekOrigin> for SeekOrigin {
155        #[inline]
156        fn from_wire(wire: crate::wire::SeekOrigin) -> Self {
157            Self::from(wire)
158        }
159    }
160
161    impl ::fidl_next::FromWireRef<crate::wire::SeekOrigin> for SeekOrigin {
162        #[inline]
163        fn from_wire_ref(wire: &crate::wire::SeekOrigin) -> Self {
164            Self::from(*wire)
165        }
166    }
167
168    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
169    pub struct AdvisoryLockRange {
170        pub origin: crate::natural::SeekOrigin,
171
172        pub offset: i64,
173
174        pub length: i64,
175    }
176
177    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E> for AdvisoryLockRange
178    where
179        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
180    {
181        #[inline]
182        fn encode(
183            self,
184            encoder_: &mut ___E,
185            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
186            _: (),
187        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
188            ::fidl_next::munge! {
189                let crate::wire::AdvisoryLockRange {
190                    origin,
191                    offset,
192                    length,
193
194                } = out_;
195            }
196
197            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
198
199            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
200
201            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
202
203            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
204
205            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
206
207            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
208
209            Ok(())
210        }
211    }
212
213    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
214        for &'a AdvisoryLockRange
215    where
216        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
217    {
218        #[inline]
219        fn encode(
220            self,
221            encoder_: &mut ___E,
222            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
223            _: (),
224        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
225            ::fidl_next::munge! {
226                let crate::wire::AdvisoryLockRange {
227                    origin,
228                    offset,
229                    length,
230
231                } = out_;
232            }
233
234            ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
235
236            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
237
238            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
239
240            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
241
242            ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
243
244            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
245
246            Ok(())
247        }
248    }
249
250    unsafe impl<___E>
251        ::fidl_next::EncodeOption<
252            ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
253            ___E,
254        > for AdvisoryLockRange
255    where
256        ___E: ::fidl_next::Encoder + ?Sized,
257        AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
258    {
259        #[inline]
260        fn encode_option(
261            this: ::core::option::Option<Self>,
262            encoder: &mut ___E,
263            out: &mut ::core::mem::MaybeUninit<
264                ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
265            >,
266            _: (),
267        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
268            if let Some(inner) = this {
269                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
270                ::fidl_next::wire::Box::encode_present(out);
271            } else {
272                ::fidl_next::wire::Box::encode_absent(out);
273            }
274
275            Ok(())
276        }
277    }
278
279    unsafe impl<'a, ___E>
280        ::fidl_next::EncodeOption<
281            ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
282            ___E,
283        > for &'a AdvisoryLockRange
284    where
285        ___E: ::fidl_next::Encoder + ?Sized,
286        &'a AdvisoryLockRange: ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>,
287    {
288        #[inline]
289        fn encode_option(
290            this: ::core::option::Option<Self>,
291            encoder: &mut ___E,
292            out: &mut ::core::mem::MaybeUninit<
293                ::fidl_next::wire::Box<'static, crate::wire::AdvisoryLockRange>,
294            >,
295            _: (),
296        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
297            if let Some(inner) = this {
298                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
299                ::fidl_next::wire::Box::encode_present(out);
300            } else {
301                ::fidl_next::wire::Box::encode_absent(out);
302            }
303
304            Ok(())
305        }
306    }
307
308    impl ::fidl_next::FromWire<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
309        #[inline]
310        fn from_wire(wire: crate::wire::AdvisoryLockRange) -> Self {
311            Self {
312                origin: ::fidl_next::FromWire::from_wire(wire.origin),
313
314                offset: ::fidl_next::FromWire::from_wire(wire.offset),
315
316                length: ::fidl_next::FromWire::from_wire(wire.length),
317            }
318        }
319    }
320
321    impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRange> for AdvisoryLockRange {
322        #[inline]
323        fn from_wire_ref(wire: &crate::wire::AdvisoryLockRange) -> Self {
324            Self {
325                origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
326
327                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
328
329                length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length),
330            }
331        }
332    }
333
334    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
335    #[repr(u32)]
336    pub enum AdvisoryLockType {
337        Read = 1,
338        Write = 2,
339        Unlock = 3,
340    }
341    impl ::core::convert::TryFrom<u32> for AdvisoryLockType {
342        type Error = ::fidl_next::UnknownStrictEnumMemberError;
343        fn try_from(
344            value: u32,
345        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
346            match value {
347                1 => Ok(Self::Read),
348                2 => Ok(Self::Write),
349                3 => Ok(Self::Unlock),
350
351                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
352            }
353        }
354    }
355
356    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E> for AdvisoryLockType
357    where
358        ___E: ?Sized,
359    {
360        #[inline]
361        fn encode(
362            self,
363            encoder: &mut ___E,
364            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
365            _: (),
366        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
367            ::fidl_next::Encode::encode(&self, encoder, out, ())
368        }
369    }
370
371    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockType, ___E>
372        for &'a AdvisoryLockType
373    where
374        ___E: ?Sized,
375    {
376        #[inline]
377        fn encode(
378            self,
379            encoder: &mut ___E,
380            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockType>,
381            _: (),
382        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
383            ::fidl_next::munge!(let crate::wire::AdvisoryLockType { value } = out);
384            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
385                AdvisoryLockType::Read => 1,
386
387                AdvisoryLockType::Write => 2,
388
389                AdvisoryLockType::Unlock => 3,
390            }));
391
392            Ok(())
393        }
394    }
395
396    impl ::core::convert::From<crate::wire::AdvisoryLockType> for AdvisoryLockType {
397        fn from(wire: crate::wire::AdvisoryLockType) -> Self {
398            match u32::from(wire.value) {
399                1 => Self::Read,
400
401                2 => Self::Write,
402
403                3 => Self::Unlock,
404
405                _ => unsafe { ::core::hint::unreachable_unchecked() },
406            }
407        }
408    }
409
410    impl ::fidl_next::FromWire<crate::wire::AdvisoryLockType> for AdvisoryLockType {
411        #[inline]
412        fn from_wire(wire: crate::wire::AdvisoryLockType) -> Self {
413            Self::from(wire)
414        }
415    }
416
417    impl ::fidl_next::FromWireRef<crate::wire::AdvisoryLockType> for AdvisoryLockType {
418        #[inline]
419        fn from_wire_ref(wire: &crate::wire::AdvisoryLockType) -> Self {
420            Self::from(*wire)
421        }
422    }
423
424    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
425    pub struct AdvisoryLockRequest {
426        pub type_: ::core::option::Option<crate::natural::AdvisoryLockType>,
427
428        pub range: ::core::option::Option<crate::natural::AdvisoryLockRange>,
429
430        pub wait: ::core::option::Option<bool>,
431    }
432
433    impl AdvisoryLockRequest {
434        fn __max_ordinal(&self) -> usize {
435            if self.wait.is_some() {
436                return 3;
437            }
438
439            if self.range.is_some() {
440                return 2;
441            }
442
443            if self.type_.is_some() {
444                return 1;
445            }
446
447            0
448        }
449    }
450
451    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
452        for AdvisoryLockRequest
453    where
454        ___E: ::fidl_next::Encoder + ?Sized,
455    {
456        #[inline]
457        fn encode(
458            mut self,
459            encoder: &mut ___E,
460            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
461            _: (),
462        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
463            ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
464
465            let max_ord = self.__max_ordinal();
466
467            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
468            ::fidl_next::Wire::zero_padding(&mut out);
469
470            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
471                ::fidl_next::wire::Envelope,
472            >(encoder, max_ord);
473
474            for i in 1..=max_ord {
475                match i {
476                    3 => {
477                        if let Some(value) = self.wait.take() {
478                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
479                                value,
480                                preallocated.encoder,
481                                &mut out,
482                                (),
483                            )?;
484                        } else {
485                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
486                        }
487                    }
488
489                    2 => {
490                        if let Some(value) = self.range.take() {
491                            ::fidl_next::wire::Envelope::encode_value::<
492                                crate::wire::AdvisoryLockRange,
493                                ___E,
494                            >(
495                                value, preallocated.encoder, &mut out, ()
496                            )?;
497                        } else {
498                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
499                        }
500                    }
501
502                    1 => {
503                        if let Some(value) = self.type_.take() {
504                            ::fidl_next::wire::Envelope::encode_value::<
505                                crate::wire::AdvisoryLockType,
506                                ___E,
507                            >(
508                                value, preallocated.encoder, &mut out, ()
509                            )?;
510                        } else {
511                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
512                        }
513                    }
514
515                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
516                }
517                unsafe {
518                    preallocated.write_next(out.assume_init_ref());
519                }
520            }
521
522            ::fidl_next::wire::Table::encode_len(table, max_ord);
523
524            Ok(())
525        }
526    }
527
528    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>
529        for &'a AdvisoryLockRequest
530    where
531        ___E: ::fidl_next::Encoder + ?Sized,
532    {
533        #[inline]
534        fn encode(
535            self,
536            encoder: &mut ___E,
537            out: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRequest<'static>>,
538            _: (),
539        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
540            ::fidl_next::munge!(let crate::wire::AdvisoryLockRequest { table } = out);
541
542            let max_ord = self.__max_ordinal();
543
544            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
545            ::fidl_next::Wire::zero_padding(&mut out);
546
547            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
548                ::fidl_next::wire::Envelope,
549            >(encoder, max_ord);
550
551            for i in 1..=max_ord {
552                match i {
553                    3 => {
554                        if let Some(value) = &self.wait {
555                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
556                                value,
557                                preallocated.encoder,
558                                &mut out,
559                                (),
560                            )?;
561                        } else {
562                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
563                        }
564                    }
565
566                    2 => {
567                        if let Some(value) = &self.range {
568                            ::fidl_next::wire::Envelope::encode_value::<
569                                crate::wire::AdvisoryLockRange,
570                                ___E,
571                            >(
572                                value, preallocated.encoder, &mut out, ()
573                            )?;
574                        } else {
575                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
576                        }
577                    }
578
579                    1 => {
580                        if let Some(value) = &self.type_ {
581                            ::fidl_next::wire::Envelope::encode_value::<
582                                crate::wire::AdvisoryLockType,
583                                ___E,
584                            >(
585                                value, preallocated.encoder, &mut out, ()
586                            )?;
587                        } else {
588                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
589                        }
590                    }
591
592                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
593                }
594                unsafe {
595                    preallocated.write_next(out.assume_init_ref());
596                }
597            }
598
599            ::fidl_next::wire::Table::encode_len(table, max_ord);
600
601            Ok(())
602        }
603    }
604
605    impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
606        #[inline]
607        fn from_wire(wire_: crate::wire::AdvisoryLockRequest<'de>) -> Self {
608            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
609
610            let type_ = wire_.table.get(1);
611
612            let range = wire_.table.get(2);
613
614            let wait = wire_.table.get(3);
615
616            Self {
617                type_: type_.map(|envelope| {
618                    ::fidl_next::FromWire::from_wire(unsafe {
619                        envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
620                    })
621                }),
622
623                range: range.map(|envelope| {
624                    ::fidl_next::FromWire::from_wire(unsafe {
625                        envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
626                    })
627                }),
628
629                wait: wait.map(|envelope| {
630                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
631                }),
632            }
633        }
634    }
635
636    impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockRequest<'de>> for AdvisoryLockRequest {
637        #[inline]
638        fn from_wire_ref(wire: &crate::wire::AdvisoryLockRequest<'de>) -> Self {
639            Self {
640                type_: wire.table.get(1).map(|envelope| {
641                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
642                        envelope.deref_unchecked::<crate::wire::AdvisoryLockType>()
643                    })
644                }),
645
646                range: wire.table.get(2).map(|envelope| {
647                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
648                        envelope.deref_unchecked::<crate::wire::AdvisoryLockRange>()
649                    })
650                }),
651
652                wait: wire.table.get(3).map(|envelope| {
653                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
654                        envelope.deref_unchecked::<bool>()
655                    })
656                }),
657            }
658        }
659    }
660
661    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
662    pub struct AdvisoryLockingAdvisoryLockRequest {
663        pub request: crate::natural::AdvisoryLockRequest,
664    }
665
666    unsafe impl<___E>
667        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
668        for AdvisoryLockingAdvisoryLockRequest
669    where
670        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
671        ___E: ::fidl_next::Encoder,
672    {
673        #[inline]
674        fn encode(
675            self,
676            encoder_: &mut ___E,
677            out_: &mut ::core::mem::MaybeUninit<
678                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
679            >,
680            _: (),
681        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
682            ::fidl_next::munge! {
683                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
684                    request,
685
686                } = out_;
687            }
688
689            ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
690
691            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
692
693            Ok(())
694        }
695    }
696
697    unsafe impl<'a, ___E>
698        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
699        for &'a AdvisoryLockingAdvisoryLockRequest
700    where
701        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
702        ___E: ::fidl_next::Encoder,
703    {
704        #[inline]
705        fn encode(
706            self,
707            encoder_: &mut ___E,
708            out_: &mut ::core::mem::MaybeUninit<
709                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
710            >,
711            _: (),
712        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
713            ::fidl_next::munge! {
714                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
715                    request,
716
717                } = out_;
718            }
719
720            ::fidl_next::Encode::encode(&self.request, encoder_, request, ())?;
721
722            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(request.as_mut_ptr()) };
723
724            Ok(())
725        }
726    }
727
728    unsafe impl<___E>
729        ::fidl_next::EncodeOption<
730            ::fidl_next::wire::Box<
731                'static,
732                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
733            >,
734            ___E,
735        > for AdvisoryLockingAdvisoryLockRequest
736    where
737        ___E: ::fidl_next::Encoder + ?Sized,
738        AdvisoryLockingAdvisoryLockRequest:
739            ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
740    {
741        #[inline]
742        fn encode_option(
743            this: ::core::option::Option<Self>,
744            encoder: &mut ___E,
745            out: &mut ::core::mem::MaybeUninit<
746                ::fidl_next::wire::Box<
747                    'static,
748                    crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
749                >,
750            >,
751            _: (),
752        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
753            if let Some(inner) = this {
754                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
755                ::fidl_next::wire::Box::encode_present(out);
756            } else {
757                ::fidl_next::wire::Box::encode_absent(out);
758            }
759
760            Ok(())
761        }
762    }
763
764    unsafe impl<'a, ___E>
765        ::fidl_next::EncodeOption<
766            ::fidl_next::wire::Box<
767                'static,
768                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
769            >,
770            ___E,
771        > for &'a AdvisoryLockingAdvisoryLockRequest
772    where
773        ___E: ::fidl_next::Encoder + ?Sized,
774        &'a AdvisoryLockingAdvisoryLockRequest:
775            ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>,
776    {
777        #[inline]
778        fn encode_option(
779            this: ::core::option::Option<Self>,
780            encoder: &mut ___E,
781            out: &mut ::core::mem::MaybeUninit<
782                ::fidl_next::wire::Box<
783                    'static,
784                    crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
785                >,
786            >,
787            _: (),
788        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
789            if let Some(inner) = this {
790                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
791                ::fidl_next::wire::Box::encode_present(out);
792            } else {
793                ::fidl_next::wire::Box::encode_absent(out);
794            }
795
796            Ok(())
797        }
798    }
799
800    impl<'de> ::fidl_next::FromWire<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
801        for AdvisoryLockingAdvisoryLockRequest
802    {
803        #[inline]
804        fn from_wire(wire: crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
805            Self { request: ::fidl_next::FromWire::from_wire(wire.request) }
806        }
807    }
808
809    impl<'de> ::fidl_next::FromWireRef<crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>>
810        for AdvisoryLockingAdvisoryLockRequest
811    {
812        #[inline]
813        fn from_wire_ref(wire: &crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>) -> Self {
814            Self { request: ::fidl_next::FromWireRef::from_wire_ref(&wire.request) }
815        }
816    }
817
818    pub type AdvisoryLockingAdvisoryLockResponse = ();
819
820    ::fidl_next::bitflags::bitflags! {
821        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct AllocateMode: u32 {
822            const KEEP_SIZE = 1;
823            const UNSHARE_RANGE = 2;
824            const PUNCH_HOLE = 4;
825            const COLLAPSE_RANGE = 8;
826            const ZERO_RANGE = 16;
827            const INSERT_RANGE = 32;
828            const _ = !0;
829        }
830    }
831
832    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for AllocateMode
833    where
834        ___E: ?Sized,
835    {
836        #[inline]
837        fn encode(
838            self,
839            encoder: &mut ___E,
840            out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
841            _: (),
842        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
843            ::fidl_next::Encode::encode(&self, encoder, out, ())
844        }
845    }
846
847    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AllocateMode, ___E> for &'a AllocateMode
848    where
849        ___E: ?Sized,
850    {
851        #[inline]
852        fn encode(
853            self,
854            _: &mut ___E,
855            out: &mut ::core::mem::MaybeUninit<crate::wire::AllocateMode>,
856            _: (),
857        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
858            ::fidl_next::munge!(let crate::wire::AllocateMode { value } = out);
859
860            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
861            Ok(())
862        }
863    }
864
865    impl ::core::convert::From<crate::wire::AllocateMode> for AllocateMode {
866        fn from(wire: crate::wire::AllocateMode) -> Self {
867            Self::from_bits_retain(u32::from(wire.value))
868        }
869    }
870
871    impl ::fidl_next::FromWire<crate::wire::AllocateMode> for AllocateMode {
872        #[inline]
873        fn from_wire(wire: crate::wire::AllocateMode) -> Self {
874            Self::from(wire)
875        }
876    }
877
878    impl ::fidl_next::FromWireRef<crate::wire::AllocateMode> for AllocateMode {
879        #[inline]
880        fn from_wire_ref(wire: &crate::wire::AllocateMode) -> Self {
881            Self::from(*wire)
882        }
883    }
884
885    #[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"]
886    pub type Rights = crate::natural::Operations;
887
888    #[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"]
889    pub type Id = u64;
890
891    ::fidl_next::bitflags::bitflags! {
892        #[doc = " DEPRECATED - Use Flags instead.\n"]#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct OpenFlags: u32 {
893            #[doc = " Can read from target object.\n"]const RIGHT_READABLE = 1;
894            #[doc = " Can write to target object.\n"]const RIGHT_WRITABLE = 2;
895            #[doc = " Connection can map target object executable.\n"]const RIGHT_EXECUTABLE = 8;
896            #[doc = " Create the object if it doesn\'t exist.\n"]const CREATE = 65536;
897            #[doc = " (with Create) Fail if the object already exists.\n"]const CREATE_IF_ABSENT = 131072;
898            #[doc = " Truncate the object before usage.\n"]const TRUNCATE = 262144;
899            #[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;
900            #[doc = " Seek to the end of the object before all writes.\n"]const APPEND = 1048576;
901            #[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;
902            #[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;
903            #[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;
904            #[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;
905            #[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;
906            #[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;
907            #[doc = " Open the target object as a block device.\n"]const BLOCK_DEVICE = 16777216;
908
909        }
910    }
911
912    unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for OpenFlags
913    where
914        ___E: ?Sized,
915    {
916        #[inline]
917        fn encode(
918            self,
919            encoder: &mut ___E,
920            out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
921            _: (),
922        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
923            ::fidl_next::Encode::encode(&self, encoder, out, ())
924        }
925    }
926
927    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::OpenFlags, ___E> for &'a OpenFlags
928    where
929        ___E: ?Sized,
930    {
931        #[inline]
932        fn encode(
933            self,
934            _: &mut ___E,
935            out: &mut ::core::mem::MaybeUninit<crate::wire::OpenFlags>,
936            _: (),
937        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
938            ::fidl_next::munge!(let crate::wire::OpenFlags { value } = out);
939
940            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
941                return Err(::fidl_next::EncodeError::InvalidStrictBits);
942            }
943
944            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
945            Ok(())
946        }
947    }
948
949    impl ::core::convert::From<crate::wire::OpenFlags> for OpenFlags {
950        fn from(wire: crate::wire::OpenFlags) -> Self {
951            Self::from_bits_retain(u32::from(wire.value))
952        }
953    }
954
955    impl ::fidl_next::FromWire<crate::wire::OpenFlags> for OpenFlags {
956        #[inline]
957        fn from_wire(wire: crate::wire::OpenFlags) -> Self {
958            Self::from(wire)
959        }
960    }
961
962    impl ::fidl_next::FromWireRef<crate::wire::OpenFlags> for OpenFlags {
963        #[inline]
964        fn from_wire_ref(wire: &crate::wire::OpenFlags) -> Self {
965            Self::from(*wire)
966        }
967    }
968
969    #[doc = " NodeAttributes defines generic information about a filesystem node.\n"]
970    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
971    pub struct NodeAttributes {
972        pub mode: u32,
973
974        pub id: u64,
975
976        pub content_size: u64,
977
978        pub storage_size: u64,
979
980        pub link_count: u64,
981
982        pub creation_time: u64,
983
984        pub modification_time: u64,
985    }
986
987    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for NodeAttributes
988    where
989        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
990    {
991        #[inline]
992        fn encode(
993            self,
994            encoder_: &mut ___E,
995            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
996            _: (),
997        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
998            ::fidl_next::munge! {
999                let crate::wire::NodeAttributes {
1000                    mode,
1001                    id,
1002                    content_size,
1003                    storage_size,
1004                    link_count,
1005                    creation_time,
1006                    modification_time,
1007
1008                } = out_;
1009            }
1010
1011            ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1012
1013            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1014
1015            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
1016
1017            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1018
1019            ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
1020
1021            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1022
1023            ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
1024
1025            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1026
1027            ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
1028
1029            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1030
1031            ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
1032
1033            let mut _field =
1034                unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1035
1036            ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
1037
1038            let mut _field =
1039                unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1040
1041            Ok(())
1042        }
1043    }
1044
1045    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes, ___E> for &'a NodeAttributes
1046    where
1047        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1048    {
1049        #[inline]
1050        fn encode(
1051            self,
1052            encoder_: &mut ___E,
1053            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
1054            _: (),
1055        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1056            ::fidl_next::munge! {
1057                let crate::wire::NodeAttributes {
1058                    mode,
1059                    id,
1060                    content_size,
1061                    storage_size,
1062                    link_count,
1063                    creation_time,
1064                    modification_time,
1065
1066                } = out_;
1067            }
1068
1069            ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
1070
1071            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1072
1073            ::fidl_next::Encode::encode(&self.id, encoder_, id, ())?;
1074
1075            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
1076
1077            ::fidl_next::Encode::encode(&self.content_size, encoder_, content_size, ())?;
1078
1079            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(content_size.as_mut_ptr()) };
1080
1081            ::fidl_next::Encode::encode(&self.storage_size, encoder_, storage_size, ())?;
1082
1083            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(storage_size.as_mut_ptr()) };
1084
1085            ::fidl_next::Encode::encode(&self.link_count, encoder_, link_count, ())?;
1086
1087            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(link_count.as_mut_ptr()) };
1088
1089            ::fidl_next::Encode::encode(&self.creation_time, encoder_, creation_time, ())?;
1090
1091            let mut _field =
1092                unsafe { ::fidl_next::Slot::new_unchecked(creation_time.as_mut_ptr()) };
1093
1094            ::fidl_next::Encode::encode(&self.modification_time, encoder_, modification_time, ())?;
1095
1096            let mut _field =
1097                unsafe { ::fidl_next::Slot::new_unchecked(modification_time.as_mut_ptr()) };
1098
1099            Ok(())
1100        }
1101    }
1102
1103    unsafe impl<___E>
1104        ::fidl_next::EncodeOption<
1105            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1106            ___E,
1107        > for NodeAttributes
1108    where
1109        ___E: ::fidl_next::Encoder + ?Sized,
1110        NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1111    {
1112        #[inline]
1113        fn encode_option(
1114            this: ::core::option::Option<Self>,
1115            encoder: &mut ___E,
1116            out: &mut ::core::mem::MaybeUninit<
1117                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1118            >,
1119            _: (),
1120        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1121            if let Some(inner) = this {
1122                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1123                ::fidl_next::wire::Box::encode_present(out);
1124            } else {
1125                ::fidl_next::wire::Box::encode_absent(out);
1126            }
1127
1128            Ok(())
1129        }
1130    }
1131
1132    unsafe impl<'a, ___E>
1133        ::fidl_next::EncodeOption<
1134            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1135            ___E,
1136        > for &'a NodeAttributes
1137    where
1138        ___E: ::fidl_next::Encoder + ?Sized,
1139        &'a NodeAttributes: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
1140    {
1141        #[inline]
1142        fn encode_option(
1143            this: ::core::option::Option<Self>,
1144            encoder: &mut ___E,
1145            out: &mut ::core::mem::MaybeUninit<
1146                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes>,
1147            >,
1148            _: (),
1149        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1150            if let Some(inner) = this {
1151                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1152                ::fidl_next::wire::Box::encode_present(out);
1153            } else {
1154                ::fidl_next::wire::Box::encode_absent(out);
1155            }
1156
1157            Ok(())
1158        }
1159    }
1160
1161    impl ::fidl_next::FromWire<crate::wire::NodeAttributes> for NodeAttributes {
1162        #[inline]
1163        fn from_wire(wire: crate::wire::NodeAttributes) -> Self {
1164            Self {
1165                mode: ::fidl_next::FromWire::from_wire(wire.mode),
1166
1167                id: ::fidl_next::FromWire::from_wire(wire.id),
1168
1169                content_size: ::fidl_next::FromWire::from_wire(wire.content_size),
1170
1171                storage_size: ::fidl_next::FromWire::from_wire(wire.storage_size),
1172
1173                link_count: ::fidl_next::FromWire::from_wire(wire.link_count),
1174
1175                creation_time: ::fidl_next::FromWire::from_wire(wire.creation_time),
1176
1177                modification_time: ::fidl_next::FromWire::from_wire(wire.modification_time),
1178            }
1179        }
1180    }
1181
1182    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributes> for NodeAttributes {
1183        #[inline]
1184        fn from_wire_ref(wire: &crate::wire::NodeAttributes) -> Self {
1185            Self {
1186                mode: ::fidl_next::FromWireRef::from_wire_ref(&wire.mode),
1187
1188                id: ::fidl_next::FromWireRef::from_wire_ref(&wire.id),
1189
1190                content_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.content_size),
1191
1192                storage_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.storage_size),
1193
1194                link_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.link_count),
1195
1196                creation_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.creation_time),
1197
1198                modification_time: ::fidl_next::FromWireRef::from_wire_ref(&wire.modification_time),
1199            }
1200        }
1201    }
1202
1203    ::fidl_next::bitflags::bitflags! {
1204        #[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 {
1205            const CREATION_TIME = 1;
1206            const MODIFICATION_TIME = 2;
1207
1208        }
1209    }
1210
1211    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E> for NodeAttributeFlags
1212    where
1213        ___E: ?Sized,
1214    {
1215        #[inline]
1216        fn encode(
1217            self,
1218            encoder: &mut ___E,
1219            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1220            _: (),
1221        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1222            ::fidl_next::Encode::encode(&self, encoder, out, ())
1223        }
1224    }
1225
1226    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>
1227        for &'a NodeAttributeFlags
1228    where
1229        ___E: ?Sized,
1230    {
1231        #[inline]
1232        fn encode(
1233            self,
1234            _: &mut ___E,
1235            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributeFlags>,
1236            _: (),
1237        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1238            ::fidl_next::munge!(let crate::wire::NodeAttributeFlags { value } = out);
1239
1240            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1241                return Err(::fidl_next::EncodeError::InvalidStrictBits);
1242            }
1243
1244            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1245            Ok(())
1246        }
1247    }
1248
1249    impl ::core::convert::From<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1250        fn from(wire: crate::wire::NodeAttributeFlags) -> Self {
1251            Self::from_bits_retain(u32::from(wire.value))
1252        }
1253    }
1254
1255    impl ::fidl_next::FromWire<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1256        #[inline]
1257        fn from_wire(wire: crate::wire::NodeAttributeFlags) -> Self {
1258            Self::from(wire)
1259        }
1260    }
1261
1262    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributeFlags> for NodeAttributeFlags {
1263        #[inline]
1264        fn from_wire_ref(wire: &crate::wire::NodeAttributeFlags) -> Self {
1265            Self::from(*wire)
1266        }
1267    }
1268
1269    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1270    pub struct NodeQueryFilesystemResponse {
1271        pub s: ::fidl_next::fuchsia::zx::Status,
1272
1273        pub info: ::core::option::Option<::std::boxed::Box<crate::natural::FilesystemInfo>>,
1274    }
1275
1276    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1277        for NodeQueryFilesystemResponse
1278    where
1279        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1280        ___E: ::fidl_next::Encoder,
1281    {
1282        #[inline]
1283        fn encode(
1284            self,
1285            encoder_: &mut ___E,
1286            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1287            _: (),
1288        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1289            ::fidl_next::munge! {
1290                let crate::wire::NodeQueryFilesystemResponse {
1291                    s,
1292                    info,
1293
1294                } = out_;
1295            }
1296
1297            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1298
1299            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1300
1301            ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1302
1303            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1304
1305            Ok(())
1306        }
1307    }
1308
1309    unsafe impl<'a, ___E>
1310        ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
1311        for &'a NodeQueryFilesystemResponse
1312    where
1313        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1314        ___E: ::fidl_next::Encoder,
1315    {
1316        #[inline]
1317        fn encode(
1318            self,
1319            encoder_: &mut ___E,
1320            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
1321            _: (),
1322        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1323            ::fidl_next::munge! {
1324                let crate::wire::NodeQueryFilesystemResponse {
1325                    s,
1326                    info,
1327
1328                } = out_;
1329            }
1330
1331            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1332
1333            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1334
1335            ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
1336
1337            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1338
1339            Ok(())
1340        }
1341    }
1342
1343    unsafe impl<___E>
1344        ::fidl_next::EncodeOption<
1345            ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1346            ___E,
1347        > for NodeQueryFilesystemResponse
1348    where
1349        ___E: ::fidl_next::Encoder + ?Sized,
1350        NodeQueryFilesystemResponse:
1351            ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1352    {
1353        #[inline]
1354        fn encode_option(
1355            this: ::core::option::Option<Self>,
1356            encoder: &mut ___E,
1357            out: &mut ::core::mem::MaybeUninit<
1358                ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1359            >,
1360            _: (),
1361        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1362            if let Some(inner) = this {
1363                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1364                ::fidl_next::wire::Box::encode_present(out);
1365            } else {
1366                ::fidl_next::wire::Box::encode_absent(out);
1367            }
1368
1369            Ok(())
1370        }
1371    }
1372
1373    unsafe impl<'a, ___E>
1374        ::fidl_next::EncodeOption<
1375            ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1376            ___E,
1377        > for &'a NodeQueryFilesystemResponse
1378    where
1379        ___E: ::fidl_next::Encoder + ?Sized,
1380        &'a NodeQueryFilesystemResponse:
1381            ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>,
1382    {
1383        #[inline]
1384        fn encode_option(
1385            this: ::core::option::Option<Self>,
1386            encoder: &mut ___E,
1387            out: &mut ::core::mem::MaybeUninit<
1388                ::fidl_next::wire::Box<'static, crate::wire::NodeQueryFilesystemResponse<'static>>,
1389            >,
1390            _: (),
1391        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1392            if let Some(inner) = this {
1393                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1394                ::fidl_next::wire::Box::encode_present(out);
1395            } else {
1396                ::fidl_next::wire::Box::encode_absent(out);
1397            }
1398
1399            Ok(())
1400        }
1401    }
1402
1403    impl<'de> ::fidl_next::FromWire<crate::wire::NodeQueryFilesystemResponse<'de>>
1404        for NodeQueryFilesystemResponse
1405    {
1406        #[inline]
1407        fn from_wire(wire: crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1408            Self {
1409                s: ::fidl_next::FromWire::from_wire(wire.s),
1410
1411                info: ::fidl_next::FromWire::from_wire(wire.info),
1412            }
1413        }
1414    }
1415
1416    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeQueryFilesystemResponse<'de>>
1417        for NodeQueryFilesystemResponse
1418    {
1419        #[inline]
1420        fn from_wire_ref(wire: &crate::wire::NodeQueryFilesystemResponse<'de>) -> Self {
1421            Self {
1422                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
1423
1424                info: ::fidl_next::FromWireRef::from_wire_ref(&wire.info),
1425            }
1426        }
1427    }
1428
1429    pub type NodeUpdateAttributesResponse = ();
1430
1431    pub type NodeSyncResponse = ();
1432
1433    ::fidl_next::bitflags::bitflags! {
1434        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct ModeType: u32 {
1435            const DO_NOT_USE = 2147483648;
1436
1437        }
1438    }
1439
1440    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for ModeType
1441    where
1442        ___E: ?Sized,
1443    {
1444        #[inline]
1445        fn encode(
1446            self,
1447            encoder: &mut ___E,
1448            out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1449            _: (),
1450        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1451            ::fidl_next::Encode::encode(&self, encoder, out, ())
1452        }
1453    }
1454
1455    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ModeType, ___E> for &'a ModeType
1456    where
1457        ___E: ?Sized,
1458    {
1459        #[inline]
1460        fn encode(
1461            self,
1462            _: &mut ___E,
1463            out: &mut ::core::mem::MaybeUninit<crate::wire::ModeType>,
1464            _: (),
1465        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1466            ::fidl_next::munge!(let crate::wire::ModeType { value } = out);
1467
1468            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
1469                return Err(::fidl_next::EncodeError::InvalidStrictBits);
1470            }
1471
1472            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
1473            Ok(())
1474        }
1475    }
1476
1477    impl ::core::convert::From<crate::wire::ModeType> for ModeType {
1478        fn from(wire: crate::wire::ModeType) -> Self {
1479            Self::from_bits_retain(u32::from(wire.value))
1480        }
1481    }
1482
1483    impl ::fidl_next::FromWire<crate::wire::ModeType> for ModeType {
1484        #[inline]
1485        fn from_wire(wire: crate::wire::ModeType) -> Self {
1486            Self::from(wire)
1487        }
1488    }
1489
1490    impl ::fidl_next::FromWireRef<crate::wire::ModeType> for ModeType {
1491        #[inline]
1492        fn from_wire_ref(wire: &crate::wire::ModeType) -> Self {
1493            Self::from(*wire)
1494        }
1495    }
1496
1497    #[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"]
1498    pub type Path = ::std::string::String;
1499
1500    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1501    #[repr(C)]
1502    pub struct DirectoryReadDirentsRequest {
1503        pub max_bytes: u64,
1504    }
1505
1506    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1507        for DirectoryReadDirentsRequest
1508    where
1509        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1510    {
1511        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1512            Self,
1513            crate::wire::DirectoryReadDirentsRequest,
1514        > = unsafe {
1515            ::fidl_next::CopyOptimization::enable_if(
1516            true
1517
1518                && <
1519                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
1520                >::COPY_OPTIMIZATION.is_enabled()
1521
1522        )
1523        };
1524
1525        #[inline]
1526        fn encode(
1527            self,
1528            encoder_: &mut ___E,
1529            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1530            _: (),
1531        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1532            ::fidl_next::munge! {
1533                let crate::wire::DirectoryReadDirentsRequest {
1534                    max_bytes,
1535
1536                } = out_;
1537            }
1538
1539            ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
1540
1541            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1542
1543            Ok(())
1544        }
1545    }
1546
1547    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
1548        for &'a DirectoryReadDirentsRequest
1549    where
1550        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1551    {
1552        #[inline]
1553        fn encode(
1554            self,
1555            encoder_: &mut ___E,
1556            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
1557            _: (),
1558        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1559            ::fidl_next::munge! {
1560                let crate::wire::DirectoryReadDirentsRequest {
1561                    max_bytes,
1562
1563                } = out_;
1564            }
1565
1566            ::fidl_next::Encode::encode(&self.max_bytes, encoder_, max_bytes, ())?;
1567
1568            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(max_bytes.as_mut_ptr()) };
1569
1570            Ok(())
1571        }
1572    }
1573
1574    unsafe impl<___E>
1575        ::fidl_next::EncodeOption<
1576            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1577            ___E,
1578        > for DirectoryReadDirentsRequest
1579    where
1580        ___E: ::fidl_next::Encoder + ?Sized,
1581        DirectoryReadDirentsRequest:
1582            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
1583    {
1584        #[inline]
1585        fn encode_option(
1586            this: ::core::option::Option<Self>,
1587            encoder: &mut ___E,
1588            out: &mut ::core::mem::MaybeUninit<
1589                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1590            >,
1591            _: (),
1592        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1593            if let Some(inner) = this {
1594                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1595                ::fidl_next::wire::Box::encode_present(out);
1596            } else {
1597                ::fidl_next::wire::Box::encode_absent(out);
1598            }
1599
1600            Ok(())
1601        }
1602    }
1603
1604    unsafe impl<'a, ___E>
1605        ::fidl_next::EncodeOption<
1606            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1607            ___E,
1608        > for &'a DirectoryReadDirentsRequest
1609    where
1610        ___E: ::fidl_next::Encoder + ?Sized,
1611        &'a DirectoryReadDirentsRequest:
1612            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>,
1613    {
1614        #[inline]
1615        fn encode_option(
1616            this: ::core::option::Option<Self>,
1617            encoder: &mut ___E,
1618            out: &mut ::core::mem::MaybeUninit<
1619                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsRequest>,
1620            >,
1621            _: (),
1622        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1623            if let Some(inner) = this {
1624                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1625                ::fidl_next::wire::Box::encode_present(out);
1626            } else {
1627                ::fidl_next::wire::Box::encode_absent(out);
1628            }
1629
1630            Ok(())
1631        }
1632    }
1633
1634    impl ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsRequest>
1635        for DirectoryReadDirentsRequest
1636    {
1637        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1638            crate::wire::DirectoryReadDirentsRequest,
1639            Self,
1640        > = unsafe {
1641            ::fidl_next::CopyOptimization::enable_if(
1642                true
1643                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
1644                        .is_enabled(),
1645            )
1646        };
1647
1648        #[inline]
1649        fn from_wire(wire: crate::wire::DirectoryReadDirentsRequest) -> Self {
1650            Self { max_bytes: ::fidl_next::FromWire::from_wire(wire.max_bytes) }
1651        }
1652    }
1653
1654    impl ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsRequest>
1655        for DirectoryReadDirentsRequest
1656    {
1657        #[inline]
1658        fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsRequest) -> Self {
1659            Self { max_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_bytes) }
1660        }
1661    }
1662
1663    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1664    pub struct DirectoryReadDirentsResponse {
1665        pub s: ::fidl_next::fuchsia::zx::Status,
1666
1667        pub dirents: ::std::vec::Vec<u8>,
1668    }
1669
1670    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
1671        for DirectoryReadDirentsResponse
1672    where
1673        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1674        ___E: ::fidl_next::Encoder,
1675    {
1676        #[inline]
1677        fn encode(
1678            self,
1679            encoder_: &mut ___E,
1680            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
1681            _: (),
1682        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1683            ::fidl_next::munge! {
1684                let crate::wire::DirectoryReadDirentsResponse {
1685                    s,
1686                    dirents,
1687
1688                } = out_;
1689            }
1690
1691            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1692
1693            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1694
1695            ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
1696
1697            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
1698            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
1699
1700            Ok(())
1701        }
1702    }
1703
1704    unsafe impl<'a, ___E>
1705        ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
1706        for &'a DirectoryReadDirentsResponse
1707    where
1708        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1709        ___E: ::fidl_next::Encoder,
1710    {
1711        #[inline]
1712        fn encode(
1713            self,
1714            encoder_: &mut ___E,
1715            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
1716            _: (),
1717        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1718            ::fidl_next::munge! {
1719                let crate::wire::DirectoryReadDirentsResponse {
1720                    s,
1721                    dirents,
1722
1723                } = out_;
1724            }
1725
1726            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1727
1728            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1729
1730            ::fidl_next::Encode::encode(&self.dirents, encoder_, dirents, (8192, ()))?;
1731
1732            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dirents.as_mut_ptr()) };
1733            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
1734
1735            Ok(())
1736        }
1737    }
1738
1739    unsafe impl<___E>
1740        ::fidl_next::EncodeOption<
1741            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1742            ___E,
1743        > for DirectoryReadDirentsResponse
1744    where
1745        ___E: ::fidl_next::Encoder + ?Sized,
1746        DirectoryReadDirentsResponse:
1747            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
1748    {
1749        #[inline]
1750        fn encode_option(
1751            this: ::core::option::Option<Self>,
1752            encoder: &mut ___E,
1753            out: &mut ::core::mem::MaybeUninit<
1754                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1755            >,
1756            _: (),
1757        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1758            if let Some(inner) = this {
1759                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1760                ::fidl_next::wire::Box::encode_present(out);
1761            } else {
1762                ::fidl_next::wire::Box::encode_absent(out);
1763            }
1764
1765            Ok(())
1766        }
1767    }
1768
1769    unsafe impl<'a, ___E>
1770        ::fidl_next::EncodeOption<
1771            ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1772            ___E,
1773        > for &'a DirectoryReadDirentsResponse
1774    where
1775        ___E: ::fidl_next::Encoder + ?Sized,
1776        &'a DirectoryReadDirentsResponse:
1777            ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>,
1778    {
1779        #[inline]
1780        fn encode_option(
1781            this: ::core::option::Option<Self>,
1782            encoder: &mut ___E,
1783            out: &mut ::core::mem::MaybeUninit<
1784                ::fidl_next::wire::Box<'static, crate::wire::DirectoryReadDirentsResponse<'static>>,
1785            >,
1786            _: (),
1787        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1788            if let Some(inner) = this {
1789                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1790                ::fidl_next::wire::Box::encode_present(out);
1791            } else {
1792                ::fidl_next::wire::Box::encode_absent(out);
1793            }
1794
1795            Ok(())
1796        }
1797    }
1798
1799    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryReadDirentsResponse<'de>>
1800        for DirectoryReadDirentsResponse
1801    {
1802        #[inline]
1803        fn from_wire(wire: crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
1804            Self {
1805                s: ::fidl_next::FromWire::from_wire(wire.s),
1806
1807                dirents: ::fidl_next::FromWire::from_wire(wire.dirents),
1808            }
1809        }
1810    }
1811
1812    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryReadDirentsResponse<'de>>
1813        for DirectoryReadDirentsResponse
1814    {
1815        #[inline]
1816        fn from_wire_ref(wire: &crate::wire::DirectoryReadDirentsResponse<'de>) -> Self {
1817            Self {
1818                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
1819
1820                dirents: ::fidl_next::FromWireRef::from_wire_ref(&wire.dirents),
1821            }
1822        }
1823    }
1824
1825    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1826    #[repr(C)]
1827    pub struct DirectoryRewindResponse {
1828        pub s: ::fidl_next::fuchsia::zx::Status,
1829    }
1830
1831    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
1832        for DirectoryRewindResponse
1833    where
1834        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1835    {
1836        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1837            Self,
1838            crate::wire::DirectoryRewindResponse,
1839        > = unsafe {
1840            ::fidl_next::CopyOptimization::enable_if(
1841                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
1842                    ::fidl_next::wire::fuchsia::Status,
1843                    ___E,
1844                >>::COPY_OPTIMIZATION
1845                    .is_enabled(),
1846            )
1847        };
1848
1849        #[inline]
1850        fn encode(
1851            self,
1852            encoder_: &mut ___E,
1853            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
1854            _: (),
1855        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1856            ::fidl_next::munge! {
1857                let crate::wire::DirectoryRewindResponse {
1858                    s,
1859
1860                } = out_;
1861            }
1862
1863            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1864
1865            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1866
1867            Ok(())
1868        }
1869    }
1870
1871    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
1872        for &'a DirectoryRewindResponse
1873    where
1874        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1875    {
1876        #[inline]
1877        fn encode(
1878            self,
1879            encoder_: &mut ___E,
1880            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
1881            _: (),
1882        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1883            ::fidl_next::munge! {
1884                let crate::wire::DirectoryRewindResponse {
1885                    s,
1886
1887                } = out_;
1888            }
1889
1890            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
1891
1892            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1893
1894            Ok(())
1895        }
1896    }
1897
1898    unsafe impl<___E>
1899        ::fidl_next::EncodeOption<
1900            ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1901            ___E,
1902        > for DirectoryRewindResponse
1903    where
1904        ___E: ::fidl_next::Encoder + ?Sized,
1905        DirectoryRewindResponse: ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
1906    {
1907        #[inline]
1908        fn encode_option(
1909            this: ::core::option::Option<Self>,
1910            encoder: &mut ___E,
1911            out: &mut ::core::mem::MaybeUninit<
1912                ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1913            >,
1914            _: (),
1915        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1916            if let Some(inner) = this {
1917                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1918                ::fidl_next::wire::Box::encode_present(out);
1919            } else {
1920                ::fidl_next::wire::Box::encode_absent(out);
1921            }
1922
1923            Ok(())
1924        }
1925    }
1926
1927    unsafe impl<'a, ___E>
1928        ::fidl_next::EncodeOption<
1929            ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1930            ___E,
1931        > for &'a DirectoryRewindResponse
1932    where
1933        ___E: ::fidl_next::Encoder + ?Sized,
1934        &'a DirectoryRewindResponse:
1935            ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>,
1936    {
1937        #[inline]
1938        fn encode_option(
1939            this: ::core::option::Option<Self>,
1940            encoder: &mut ___E,
1941            out: &mut ::core::mem::MaybeUninit<
1942                ::fidl_next::wire::Box<'static, crate::wire::DirectoryRewindResponse>,
1943            >,
1944            _: (),
1945        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1946            if let Some(inner) = this {
1947                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1948                ::fidl_next::wire::Box::encode_present(out);
1949            } else {
1950                ::fidl_next::wire::Box::encode_absent(out);
1951            }
1952
1953            Ok(())
1954        }
1955    }
1956
1957    impl ::fidl_next::FromWire<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
1958        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1959            crate::wire::DirectoryRewindResponse,
1960            Self,
1961        > = unsafe {
1962            ::fidl_next::CopyOptimization::enable_if(
1963                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
1964                    ::fidl_next::wire::fuchsia::Status,
1965                >>::COPY_OPTIMIZATION
1966                    .is_enabled(),
1967            )
1968        };
1969
1970        #[inline]
1971        fn from_wire(wire: crate::wire::DirectoryRewindResponse) -> Self {
1972            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
1973        }
1974    }
1975
1976    impl ::fidl_next::FromWireRef<crate::wire::DirectoryRewindResponse> for DirectoryRewindResponse {
1977        #[inline]
1978        fn from_wire_ref(wire: &crate::wire::DirectoryRewindResponse) -> Self {
1979            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
1980        }
1981    }
1982
1983    #[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"]
1984    pub type Name = ::std::string::String;
1985
1986    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1987    #[repr(C)]
1988    pub struct DirectoryLinkResponse {
1989        pub s: ::fidl_next::fuchsia::zx::Status,
1990    }
1991
1992    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
1993        for DirectoryLinkResponse
1994    where
1995        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1996    {
1997        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1998            Self,
1999            crate::wire::DirectoryLinkResponse,
2000        > = unsafe {
2001            ::fidl_next::CopyOptimization::enable_if(
2002                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
2003                    ::fidl_next::wire::fuchsia::Status,
2004                    ___E,
2005                >>::COPY_OPTIMIZATION
2006                    .is_enabled(),
2007            )
2008        };
2009
2010        #[inline]
2011        fn encode(
2012            self,
2013            encoder_: &mut ___E,
2014            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2015            _: (),
2016        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2017            ::fidl_next::munge! {
2018                let crate::wire::DirectoryLinkResponse {
2019                    s,
2020
2021                } = out_;
2022            }
2023
2024            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2025
2026            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2027
2028            Ok(())
2029        }
2030    }
2031
2032    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
2033        for &'a DirectoryLinkResponse
2034    where
2035        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2036    {
2037        #[inline]
2038        fn encode(
2039            self,
2040            encoder_: &mut ___E,
2041            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
2042            _: (),
2043        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2044            ::fidl_next::munge! {
2045                let crate::wire::DirectoryLinkResponse {
2046                    s,
2047
2048                } = out_;
2049            }
2050
2051            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2052
2053            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2054
2055            Ok(())
2056        }
2057    }
2058
2059    unsafe impl<___E>
2060        ::fidl_next::EncodeOption<
2061            ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2062            ___E,
2063        > for DirectoryLinkResponse
2064    where
2065        ___E: ::fidl_next::Encoder + ?Sized,
2066        DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2067    {
2068        #[inline]
2069        fn encode_option(
2070            this: ::core::option::Option<Self>,
2071            encoder: &mut ___E,
2072            out: &mut ::core::mem::MaybeUninit<
2073                ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2074            >,
2075            _: (),
2076        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2077            if let Some(inner) = this {
2078                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2079                ::fidl_next::wire::Box::encode_present(out);
2080            } else {
2081                ::fidl_next::wire::Box::encode_absent(out);
2082            }
2083
2084            Ok(())
2085        }
2086    }
2087
2088    unsafe impl<'a, ___E>
2089        ::fidl_next::EncodeOption<
2090            ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2091            ___E,
2092        > for &'a DirectoryLinkResponse
2093    where
2094        ___E: ::fidl_next::Encoder + ?Sized,
2095        &'a DirectoryLinkResponse: ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>,
2096    {
2097        #[inline]
2098        fn encode_option(
2099            this: ::core::option::Option<Self>,
2100            encoder: &mut ___E,
2101            out: &mut ::core::mem::MaybeUninit<
2102                ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkResponse>,
2103            >,
2104            _: (),
2105        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2106            if let Some(inner) = this {
2107                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2108                ::fidl_next::wire::Box::encode_present(out);
2109            } else {
2110                ::fidl_next::wire::Box::encode_absent(out);
2111            }
2112
2113            Ok(())
2114        }
2115    }
2116
2117    impl ::fidl_next::FromWire<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2118        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2119            crate::wire::DirectoryLinkResponse,
2120            Self,
2121        > = unsafe {
2122            ::fidl_next::CopyOptimization::enable_if(
2123                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
2124                    ::fidl_next::wire::fuchsia::Status,
2125                >>::COPY_OPTIMIZATION
2126                    .is_enabled(),
2127            )
2128        };
2129
2130        #[inline]
2131        fn from_wire(wire: crate::wire::DirectoryLinkResponse) -> Self {
2132            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2133        }
2134    }
2135
2136    impl ::fidl_next::FromWireRef<crate::wire::DirectoryLinkResponse> for DirectoryLinkResponse {
2137        #[inline]
2138        fn from_wire_ref(wire: &crate::wire::DirectoryLinkResponse) -> Self {
2139            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2140        }
2141    }
2142
2143    ::fidl_next::bitflags::bitflags! {
2144        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct UnlinkFlags: u64 {
2145            #[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;
2146            const _ = !0;
2147        }
2148    }
2149
2150    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for UnlinkFlags
2151    where
2152        ___E: ?Sized,
2153    {
2154        #[inline]
2155        fn encode(
2156            self,
2157            encoder: &mut ___E,
2158            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2159            _: (),
2160        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2161            ::fidl_next::Encode::encode(&self, encoder, out, ())
2162        }
2163    }
2164
2165    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkFlags, ___E> for &'a UnlinkFlags
2166    where
2167        ___E: ?Sized,
2168    {
2169        #[inline]
2170        fn encode(
2171            self,
2172            _: &mut ___E,
2173            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkFlags>,
2174            _: (),
2175        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2176            ::fidl_next::munge!(let crate::wire::UnlinkFlags { value } = out);
2177
2178            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
2179            Ok(())
2180        }
2181    }
2182
2183    impl ::core::convert::From<crate::wire::UnlinkFlags> for UnlinkFlags {
2184        fn from(wire: crate::wire::UnlinkFlags) -> Self {
2185            Self::from_bits_retain(u64::from(wire.value))
2186        }
2187    }
2188
2189    impl ::fidl_next::FromWire<crate::wire::UnlinkFlags> for UnlinkFlags {
2190        #[inline]
2191        fn from_wire(wire: crate::wire::UnlinkFlags) -> Self {
2192            Self::from(wire)
2193        }
2194    }
2195
2196    impl ::fidl_next::FromWireRef<crate::wire::UnlinkFlags> for UnlinkFlags {
2197        #[inline]
2198        fn from_wire_ref(wire: &crate::wire::UnlinkFlags) -> Self {
2199            Self::from(*wire)
2200        }
2201    }
2202
2203    #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2204    pub struct UnlinkOptions {
2205        pub flags: ::core::option::Option<crate::natural::UnlinkFlags>,
2206    }
2207
2208    impl UnlinkOptions {
2209        fn __max_ordinal(&self) -> usize {
2210            if self.flags.is_some() {
2211                return 1;
2212            }
2213
2214            0
2215        }
2216    }
2217
2218    unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E> for UnlinkOptions
2219    where
2220        ___E: ::fidl_next::Encoder + ?Sized,
2221    {
2222        #[inline]
2223        fn encode(
2224            mut self,
2225            encoder: &mut ___E,
2226            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2227            _: (),
2228        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2229            ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2230
2231            let max_ord = self.__max_ordinal();
2232
2233            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2234            ::fidl_next::Wire::zero_padding(&mut out);
2235
2236            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2237                ::fidl_next::wire::Envelope,
2238            >(encoder, max_ord);
2239
2240            for i in 1..=max_ord {
2241                match i {
2242                    1 => {
2243                        if let Some(value) = self.flags.take() {
2244                            ::fidl_next::wire::Envelope::encode_value::<
2245                                crate::wire::UnlinkFlags,
2246                                ___E,
2247                            >(
2248                                value, preallocated.encoder, &mut out, ()
2249                            )?;
2250                        } else {
2251                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
2252                        }
2253                    }
2254
2255                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2256                }
2257                unsafe {
2258                    preallocated.write_next(out.assume_init_ref());
2259                }
2260            }
2261
2262            ::fidl_next::wire::Table::encode_len(table, max_ord);
2263
2264            Ok(())
2265        }
2266    }
2267
2268    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>
2269        for &'a UnlinkOptions
2270    where
2271        ___E: ::fidl_next::Encoder + ?Sized,
2272    {
2273        #[inline]
2274        fn encode(
2275            self,
2276            encoder: &mut ___E,
2277            out: &mut ::core::mem::MaybeUninit<crate::wire::UnlinkOptions<'static>>,
2278            _: (),
2279        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2280            ::fidl_next::munge!(let crate::wire::UnlinkOptions { table } = out);
2281
2282            let max_ord = self.__max_ordinal();
2283
2284            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2285            ::fidl_next::Wire::zero_padding(&mut out);
2286
2287            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2288                ::fidl_next::wire::Envelope,
2289            >(encoder, max_ord);
2290
2291            for i in 1..=max_ord {
2292                match i {
2293                    1 => {
2294                        if let Some(value) = &self.flags {
2295                            ::fidl_next::wire::Envelope::encode_value::<
2296                                crate::wire::UnlinkFlags,
2297                                ___E,
2298                            >(
2299                                value, preallocated.encoder, &mut out, ()
2300                            )?;
2301                        } else {
2302                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
2303                        }
2304                    }
2305
2306                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2307                }
2308                unsafe {
2309                    preallocated.write_next(out.assume_init_ref());
2310                }
2311            }
2312
2313            ::fidl_next::wire::Table::encode_len(table, max_ord);
2314
2315            Ok(())
2316        }
2317    }
2318
2319    impl<'de> ::fidl_next::FromWire<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2320        #[inline]
2321        fn from_wire(wire_: crate::wire::UnlinkOptions<'de>) -> Self {
2322            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2323
2324            let flags = wire_.table.get(1);
2325
2326            Self {
2327                flags: flags.map(|envelope| {
2328                    ::fidl_next::FromWire::from_wire(unsafe {
2329                        envelope.read_unchecked::<crate::wire::UnlinkFlags>()
2330                    })
2331                }),
2332            }
2333        }
2334    }
2335
2336    impl<'de> ::fidl_next::FromWireRef<crate::wire::UnlinkOptions<'de>> for UnlinkOptions {
2337        #[inline]
2338        fn from_wire_ref(wire: &crate::wire::UnlinkOptions<'de>) -> Self {
2339            Self {
2340                flags: wire.table.get(1).map(|envelope| {
2341                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2342                        envelope.deref_unchecked::<crate::wire::UnlinkFlags>()
2343                    })
2344                }),
2345            }
2346        }
2347    }
2348
2349    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2350    pub struct DirectoryUnlinkRequest {
2351        pub name: ::std::string::String,
2352
2353        pub options: crate::natural::UnlinkOptions,
2354    }
2355
2356    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2357        for DirectoryUnlinkRequest
2358    where
2359        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2360        ___E: ::fidl_next::Encoder,
2361    {
2362        #[inline]
2363        fn encode(
2364            self,
2365            encoder_: &mut ___E,
2366            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2367            _: (),
2368        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2369            ::fidl_next::munge! {
2370                let crate::wire::DirectoryUnlinkRequest {
2371                    name,
2372                    options,
2373
2374                } = out_;
2375            }
2376
2377            ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
2378
2379            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2380            ::fidl_next::Constrained::validate(_field, 255)?;
2381
2382            ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
2383
2384            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2385
2386            Ok(())
2387        }
2388    }
2389
2390    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
2391        for &'a DirectoryUnlinkRequest
2392    where
2393        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2394        ___E: ::fidl_next::Encoder,
2395    {
2396        #[inline]
2397        fn encode(
2398            self,
2399            encoder_: &mut ___E,
2400            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
2401            _: (),
2402        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2403            ::fidl_next::munge! {
2404                let crate::wire::DirectoryUnlinkRequest {
2405                    name,
2406                    options,
2407
2408                } = out_;
2409            }
2410
2411            ::fidl_next::Encode::encode(&self.name, encoder_, name, 255)?;
2412
2413            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2414            ::fidl_next::Constrained::validate(_field, 255)?;
2415
2416            ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
2417
2418            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
2419
2420            Ok(())
2421        }
2422    }
2423
2424    unsafe impl<___E>
2425        ::fidl_next::EncodeOption<
2426            ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2427            ___E,
2428        > for DirectoryUnlinkRequest
2429    where
2430        ___E: ::fidl_next::Encoder + ?Sized,
2431        DirectoryUnlinkRequest:
2432            ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2433    {
2434        #[inline]
2435        fn encode_option(
2436            this: ::core::option::Option<Self>,
2437            encoder: &mut ___E,
2438            out: &mut ::core::mem::MaybeUninit<
2439                ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2440            >,
2441            _: (),
2442        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2443            if let Some(inner) = this {
2444                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2445                ::fidl_next::wire::Box::encode_present(out);
2446            } else {
2447                ::fidl_next::wire::Box::encode_absent(out);
2448            }
2449
2450            Ok(())
2451        }
2452    }
2453
2454    unsafe impl<'a, ___E>
2455        ::fidl_next::EncodeOption<
2456            ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2457            ___E,
2458        > for &'a DirectoryUnlinkRequest
2459    where
2460        ___E: ::fidl_next::Encoder + ?Sized,
2461        &'a DirectoryUnlinkRequest:
2462            ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>,
2463    {
2464        #[inline]
2465        fn encode_option(
2466            this: ::core::option::Option<Self>,
2467            encoder: &mut ___E,
2468            out: &mut ::core::mem::MaybeUninit<
2469                ::fidl_next::wire::Box<'static, crate::wire::DirectoryUnlinkRequest<'static>>,
2470            >,
2471            _: (),
2472        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2473            if let Some(inner) = this {
2474                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2475                ::fidl_next::wire::Box::encode_present(out);
2476            } else {
2477                ::fidl_next::wire::Box::encode_absent(out);
2478            }
2479
2480            Ok(())
2481        }
2482    }
2483
2484    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryUnlinkRequest<'de>>
2485        for DirectoryUnlinkRequest
2486    {
2487        #[inline]
2488        fn from_wire(wire: crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2489            Self {
2490                name: ::fidl_next::FromWire::from_wire(wire.name),
2491
2492                options: ::fidl_next::FromWire::from_wire(wire.options),
2493            }
2494        }
2495    }
2496
2497    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryUnlinkRequest<'de>>
2498        for DirectoryUnlinkRequest
2499    {
2500        #[inline]
2501        fn from_wire_ref(wire: &crate::wire::DirectoryUnlinkRequest<'de>) -> Self {
2502            Self {
2503                name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
2504
2505                options: ::fidl_next::FromWireRef::from_wire_ref(&wire.options),
2506            }
2507        }
2508    }
2509
2510    pub type DirectoryUnlinkResponse = ();
2511
2512    pub type DirectoryRenameResponse = ();
2513
2514    ::fidl_next::bitflags::bitflags! {
2515        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct WatchMask: u32 {
2516            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.DELETED`.\n"]const DELETED = 1;
2517            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.ADDED`.\n"]const ADDED = 2;
2518            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.REMOVED`.\n"]const REMOVED = 4;
2519            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.EXISTING`.\n"]const EXISTING = 8;
2520            #[doc = " Used by `Directory.Watch`. Requests transmission of `WatchEvent.IDLE`.\n"]const IDLE = 16;
2521
2522        }
2523    }
2524
2525    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for WatchMask
2526    where
2527        ___E: ?Sized,
2528    {
2529        #[inline]
2530        fn encode(
2531            self,
2532            encoder: &mut ___E,
2533            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
2534            _: (),
2535        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2536            ::fidl_next::Encode::encode(&self, encoder, out, ())
2537        }
2538    }
2539
2540    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchMask, ___E> for &'a WatchMask
2541    where
2542        ___E: ?Sized,
2543    {
2544        #[inline]
2545        fn encode(
2546            self,
2547            _: &mut ___E,
2548            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchMask>,
2549            _: (),
2550        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2551            ::fidl_next::munge!(let crate::wire::WatchMask { value } = out);
2552
2553            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
2554                return Err(::fidl_next::EncodeError::InvalidStrictBits);
2555            }
2556
2557            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
2558            Ok(())
2559        }
2560    }
2561
2562    impl ::core::convert::From<crate::wire::WatchMask> for WatchMask {
2563        fn from(wire: crate::wire::WatchMask) -> Self {
2564            Self::from_bits_retain(u32::from(wire.value))
2565        }
2566    }
2567
2568    impl ::fidl_next::FromWire<crate::wire::WatchMask> for WatchMask {
2569        #[inline]
2570        fn from_wire(wire: crate::wire::WatchMask) -> Self {
2571            Self::from(wire)
2572        }
2573    }
2574
2575    impl ::fidl_next::FromWireRef<crate::wire::WatchMask> for WatchMask {
2576        #[inline]
2577        fn from_wire_ref(wire: &crate::wire::WatchMask) -> Self {
2578            Self::from(*wire)
2579        }
2580    }
2581
2582    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2583    #[repr(C)]
2584    pub struct DirectoryWatchResponse {
2585        pub s: ::fidl_next::fuchsia::zx::Status,
2586    }
2587
2588    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
2589        for DirectoryWatchResponse
2590    where
2591        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2592    {
2593        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2594            Self,
2595            crate::wire::DirectoryWatchResponse,
2596        > = unsafe {
2597            ::fidl_next::CopyOptimization::enable_if(
2598                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
2599                    ::fidl_next::wire::fuchsia::Status,
2600                    ___E,
2601                >>::COPY_OPTIMIZATION
2602                    .is_enabled(),
2603            )
2604        };
2605
2606        #[inline]
2607        fn encode(
2608            self,
2609            encoder_: &mut ___E,
2610            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
2611            _: (),
2612        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2613            ::fidl_next::munge! {
2614                let crate::wire::DirectoryWatchResponse {
2615                    s,
2616
2617                } = out_;
2618            }
2619
2620            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
2621
2622            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2623
2624            Ok(())
2625        }
2626    }
2627
2628    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
2629        for &'a DirectoryWatchResponse
2630    where
2631        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2632    {
2633        #[inline]
2634        fn encode(
2635            self,
2636            encoder_: &mut ___E,
2637            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
2638            _: (),
2639        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2640            ::fidl_next::munge! {
2641                let crate::wire::DirectoryWatchResponse {
2642                    s,
2643
2644                } = out_;
2645            }
2646
2647            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
2648
2649            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
2650
2651            Ok(())
2652        }
2653    }
2654
2655    unsafe impl<___E>
2656        ::fidl_next::EncodeOption<
2657            ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2658            ___E,
2659        > for DirectoryWatchResponse
2660    where
2661        ___E: ::fidl_next::Encoder + ?Sized,
2662        DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
2663    {
2664        #[inline]
2665        fn encode_option(
2666            this: ::core::option::Option<Self>,
2667            encoder: &mut ___E,
2668            out: &mut ::core::mem::MaybeUninit<
2669                ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2670            >,
2671            _: (),
2672        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2673            if let Some(inner) = this {
2674                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2675                ::fidl_next::wire::Box::encode_present(out);
2676            } else {
2677                ::fidl_next::wire::Box::encode_absent(out);
2678            }
2679
2680            Ok(())
2681        }
2682    }
2683
2684    unsafe impl<'a, ___E>
2685        ::fidl_next::EncodeOption<
2686            ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2687            ___E,
2688        > for &'a DirectoryWatchResponse
2689    where
2690        ___E: ::fidl_next::Encoder + ?Sized,
2691        &'a DirectoryWatchResponse: ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>,
2692    {
2693        #[inline]
2694        fn encode_option(
2695            this: ::core::option::Option<Self>,
2696            encoder: &mut ___E,
2697            out: &mut ::core::mem::MaybeUninit<
2698                ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchResponse>,
2699            >,
2700            _: (),
2701        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2702            if let Some(inner) = this {
2703                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2704                ::fidl_next::wire::Box::encode_present(out);
2705            } else {
2706                ::fidl_next::wire::Box::encode_absent(out);
2707            }
2708
2709            Ok(())
2710        }
2711    }
2712
2713    impl ::fidl_next::FromWire<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
2714        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2715            crate::wire::DirectoryWatchResponse,
2716            Self,
2717        > = unsafe {
2718            ::fidl_next::CopyOptimization::enable_if(
2719                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
2720                    ::fidl_next::wire::fuchsia::Status,
2721                >>::COPY_OPTIMIZATION
2722                    .is_enabled(),
2723            )
2724        };
2725
2726        #[inline]
2727        fn from_wire(wire: crate::wire::DirectoryWatchResponse) -> Self {
2728            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
2729        }
2730    }
2731
2732    impl ::fidl_next::FromWireRef<crate::wire::DirectoryWatchResponse> for DirectoryWatchResponse {
2733        #[inline]
2734        fn from_wire_ref(wire: &crate::wire::DirectoryWatchResponse) -> Self {
2735            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
2736        }
2737    }
2738
2739    pub type SymlinkTarget = ::std::vec::Vec<u8>;
2740
2741    #[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"]
2742    pub type ExtendedAttributeName = ::std::vec::Vec<u8>;
2743
2744    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2745    pub struct NodeGetExtendedAttributeRequest {
2746        pub name: ::std::vec::Vec<u8>,
2747    }
2748
2749    unsafe impl<___E>
2750        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
2751        for NodeGetExtendedAttributeRequest
2752    where
2753        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2754        ___E: ::fidl_next::Encoder,
2755    {
2756        #[inline]
2757        fn encode(
2758            self,
2759            encoder_: &mut ___E,
2760            out_: &mut ::core::mem::MaybeUninit<
2761                crate::wire::NodeGetExtendedAttributeRequest<'static>,
2762            >,
2763            _: (),
2764        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765            ::fidl_next::munge! {
2766                let crate::wire::NodeGetExtendedAttributeRequest {
2767                    name,
2768
2769                } = out_;
2770            }
2771
2772            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
2773
2774            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2775            ::fidl_next::Constrained::validate(_field, (255, ()))?;
2776
2777            Ok(())
2778        }
2779    }
2780
2781    unsafe impl<'a, ___E>
2782        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
2783        for &'a NodeGetExtendedAttributeRequest
2784    where
2785        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2786        ___E: ::fidl_next::Encoder,
2787    {
2788        #[inline]
2789        fn encode(
2790            self,
2791            encoder_: &mut ___E,
2792            out_: &mut ::core::mem::MaybeUninit<
2793                crate::wire::NodeGetExtendedAttributeRequest<'static>,
2794            >,
2795            _: (),
2796        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2797            ::fidl_next::munge! {
2798                let crate::wire::NodeGetExtendedAttributeRequest {
2799                    name,
2800
2801                } = out_;
2802            }
2803
2804            ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
2805
2806            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
2807            ::fidl_next::Constrained::validate(_field, (255, ()))?;
2808
2809            Ok(())
2810        }
2811    }
2812
2813    unsafe impl<___E>
2814        ::fidl_next::EncodeOption<
2815            ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
2816            ___E,
2817        > for NodeGetExtendedAttributeRequest
2818    where
2819        ___E: ::fidl_next::Encoder + ?Sized,
2820        NodeGetExtendedAttributeRequest:
2821            ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
2822    {
2823        #[inline]
2824        fn encode_option(
2825            this: ::core::option::Option<Self>,
2826            encoder: &mut ___E,
2827            out: &mut ::core::mem::MaybeUninit<
2828                ::fidl_next::wire::Box<
2829                    'static,
2830                    crate::wire::NodeGetExtendedAttributeRequest<'static>,
2831                >,
2832            >,
2833            _: (),
2834        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2835            if let Some(inner) = this {
2836                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2837                ::fidl_next::wire::Box::encode_present(out);
2838            } else {
2839                ::fidl_next::wire::Box::encode_absent(out);
2840            }
2841
2842            Ok(())
2843        }
2844    }
2845
2846    unsafe impl<'a, ___E>
2847        ::fidl_next::EncodeOption<
2848            ::fidl_next::wire::Box<'static, crate::wire::NodeGetExtendedAttributeRequest<'static>>,
2849            ___E,
2850        > for &'a NodeGetExtendedAttributeRequest
2851    where
2852        ___E: ::fidl_next::Encoder + ?Sized,
2853        &'a NodeGetExtendedAttributeRequest:
2854            ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>,
2855    {
2856        #[inline]
2857        fn encode_option(
2858            this: ::core::option::Option<Self>,
2859            encoder: &mut ___E,
2860            out: &mut ::core::mem::MaybeUninit<
2861                ::fidl_next::wire::Box<
2862                    'static,
2863                    crate::wire::NodeGetExtendedAttributeRequest<'static>,
2864                >,
2865            >,
2866            _: (),
2867        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2868            if let Some(inner) = this {
2869                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2870                ::fidl_next::wire::Box::encode_present(out);
2871            } else {
2872                ::fidl_next::wire::Box::encode_absent(out);
2873            }
2874
2875            Ok(())
2876        }
2877    }
2878
2879    impl<'de> ::fidl_next::FromWire<crate::wire::NodeGetExtendedAttributeRequest<'de>>
2880        for NodeGetExtendedAttributeRequest
2881    {
2882        #[inline]
2883        fn from_wire(wire: crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
2884            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
2885        }
2886    }
2887
2888    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeGetExtendedAttributeRequest<'de>>
2889        for NodeGetExtendedAttributeRequest
2890    {
2891        #[inline]
2892        fn from_wire_ref(wire: &crate::wire::NodeGetExtendedAttributeRequest<'de>) -> Self {
2893            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
2894        }
2895    }
2896
2897    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2898    #[repr(u32)]
2899    pub enum SetExtendedAttributeMode {
2900        Set = 1,
2901        Create = 2,
2902        Replace = 3,
2903    }
2904    impl ::core::convert::TryFrom<u32> for SetExtendedAttributeMode {
2905        type Error = ::fidl_next::UnknownStrictEnumMemberError;
2906        fn try_from(
2907            value: u32,
2908        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
2909            match value {
2910                1 => Ok(Self::Set),
2911                2 => Ok(Self::Create),
2912                3 => Ok(Self::Replace),
2913
2914                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
2915            }
2916        }
2917    }
2918
2919    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
2920        for SetExtendedAttributeMode
2921    where
2922        ___E: ?Sized,
2923    {
2924        #[inline]
2925        fn encode(
2926            self,
2927            encoder: &mut ___E,
2928            out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
2929            _: (),
2930        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2931            ::fidl_next::Encode::encode(&self, encoder, out, ())
2932        }
2933    }
2934
2935    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>
2936        for &'a SetExtendedAttributeMode
2937    where
2938        ___E: ?Sized,
2939    {
2940        #[inline]
2941        fn encode(
2942            self,
2943            encoder: &mut ___E,
2944            out: &mut ::core::mem::MaybeUninit<crate::wire::SetExtendedAttributeMode>,
2945            _: (),
2946        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2947            ::fidl_next::munge!(let crate::wire::SetExtendedAttributeMode { value } = out);
2948            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2949                SetExtendedAttributeMode::Set => 1,
2950
2951                SetExtendedAttributeMode::Create => 2,
2952
2953                SetExtendedAttributeMode::Replace => 3,
2954            }));
2955
2956            Ok(())
2957        }
2958    }
2959
2960    impl ::core::convert::From<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2961        fn from(wire: crate::wire::SetExtendedAttributeMode) -> Self {
2962            match u32::from(wire.value) {
2963                1 => Self::Set,
2964
2965                2 => Self::Create,
2966
2967                3 => Self::Replace,
2968
2969                _ => unsafe { ::core::hint::unreachable_unchecked() },
2970            }
2971        }
2972    }
2973
2974    impl ::fidl_next::FromWire<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2975        #[inline]
2976        fn from_wire(wire: crate::wire::SetExtendedAttributeMode) -> Self {
2977            Self::from(wire)
2978        }
2979    }
2980
2981    impl ::fidl_next::FromWireRef<crate::wire::SetExtendedAttributeMode> for SetExtendedAttributeMode {
2982        #[inline]
2983        fn from_wire_ref(wire: &crate::wire::SetExtendedAttributeMode) -> Self {
2984            Self::from(*wire)
2985        }
2986    }
2987
2988    pub type NodeSetExtendedAttributeResponse = ();
2989
2990    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2991    pub struct NodeRemoveExtendedAttributeRequest {
2992        pub name: ::std::vec::Vec<u8>,
2993    }
2994
2995    unsafe impl<___E>
2996        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
2997        for NodeRemoveExtendedAttributeRequest
2998    where
2999        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3000        ___E: ::fidl_next::Encoder,
3001    {
3002        #[inline]
3003        fn encode(
3004            self,
3005            encoder_: &mut ___E,
3006            out_: &mut ::core::mem::MaybeUninit<
3007                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3008            >,
3009            _: (),
3010        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3011            ::fidl_next::munge! {
3012                let crate::wire::NodeRemoveExtendedAttributeRequest {
3013                    name,
3014
3015                } = out_;
3016            }
3017
3018            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
3019
3020            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3021            ::fidl_next::Constrained::validate(_field, (255, ()))?;
3022
3023            Ok(())
3024        }
3025    }
3026
3027    unsafe impl<'a, ___E>
3028        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
3029        for &'a NodeRemoveExtendedAttributeRequest
3030    where
3031        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3032        ___E: ::fidl_next::Encoder,
3033    {
3034        #[inline]
3035        fn encode(
3036            self,
3037            encoder_: &mut ___E,
3038            out_: &mut ::core::mem::MaybeUninit<
3039                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3040            >,
3041            _: (),
3042        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3043            ::fidl_next::munge! {
3044                let crate::wire::NodeRemoveExtendedAttributeRequest {
3045                    name,
3046
3047                } = out_;
3048            }
3049
3050            ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
3051
3052            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
3053            ::fidl_next::Constrained::validate(_field, (255, ()))?;
3054
3055            Ok(())
3056        }
3057    }
3058
3059    unsafe impl<___E>
3060        ::fidl_next::EncodeOption<
3061            ::fidl_next::wire::Box<
3062                'static,
3063                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3064            >,
3065            ___E,
3066        > for NodeRemoveExtendedAttributeRequest
3067    where
3068        ___E: ::fidl_next::Encoder + ?Sized,
3069        NodeRemoveExtendedAttributeRequest:
3070            ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3071    {
3072        #[inline]
3073        fn encode_option(
3074            this: ::core::option::Option<Self>,
3075            encoder: &mut ___E,
3076            out: &mut ::core::mem::MaybeUninit<
3077                ::fidl_next::wire::Box<
3078                    'static,
3079                    crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3080                >,
3081            >,
3082            _: (),
3083        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3084            if let Some(inner) = this {
3085                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3086                ::fidl_next::wire::Box::encode_present(out);
3087            } else {
3088                ::fidl_next::wire::Box::encode_absent(out);
3089            }
3090
3091            Ok(())
3092        }
3093    }
3094
3095    unsafe impl<'a, ___E>
3096        ::fidl_next::EncodeOption<
3097            ::fidl_next::wire::Box<
3098                'static,
3099                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3100            >,
3101            ___E,
3102        > for &'a NodeRemoveExtendedAttributeRequest
3103    where
3104        ___E: ::fidl_next::Encoder + ?Sized,
3105        &'a NodeRemoveExtendedAttributeRequest:
3106            ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>,
3107    {
3108        #[inline]
3109        fn encode_option(
3110            this: ::core::option::Option<Self>,
3111            encoder: &mut ___E,
3112            out: &mut ::core::mem::MaybeUninit<
3113                ::fidl_next::wire::Box<
3114                    'static,
3115                    crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
3116                >,
3117            >,
3118            _: (),
3119        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3120            if let Some(inner) = this {
3121                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3122                ::fidl_next::wire::Box::encode_present(out);
3123            } else {
3124                ::fidl_next::wire::Box::encode_absent(out);
3125            }
3126
3127            Ok(())
3128        }
3129    }
3130
3131    impl<'de> ::fidl_next::FromWire<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3132        for NodeRemoveExtendedAttributeRequest
3133    {
3134        #[inline]
3135        fn from_wire(wire: crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3136            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
3137        }
3138    }
3139
3140    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeRemoveExtendedAttributeRequest<'de>>
3141        for NodeRemoveExtendedAttributeRequest
3142    {
3143        #[inline]
3144        fn from_wire_ref(wire: &crate::wire::NodeRemoveExtendedAttributeRequest<'de>) -> Self {
3145            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
3146        }
3147    }
3148
3149    pub type NodeRemoveExtendedAttributeResponse = ();
3150
3151    pub type DirectoryCreateSymlinkResponse = ();
3152
3153    pub type NodeSetFlagsResponse = ();
3154
3155    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3156    pub struct NodeDeprecatedGetAttrResponse {
3157        pub s: ::fidl_next::fuchsia::zx::Status,
3158
3159        pub attributes: crate::natural::NodeAttributes,
3160    }
3161
3162    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
3163        for NodeDeprecatedGetAttrResponse
3164    where
3165        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3166    {
3167        #[inline]
3168        fn encode(
3169            self,
3170            encoder_: &mut ___E,
3171            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
3172            _: (),
3173        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3174            ::fidl_next::munge! {
3175                let crate::wire::NodeDeprecatedGetAttrResponse {
3176                    s,
3177                    attributes,
3178
3179                } = out_;
3180            }
3181
3182            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3183
3184            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3185
3186            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
3187
3188            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3189
3190            Ok(())
3191        }
3192    }
3193
3194    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
3195        for &'a NodeDeprecatedGetAttrResponse
3196    where
3197        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3198    {
3199        #[inline]
3200        fn encode(
3201            self,
3202            encoder_: &mut ___E,
3203            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
3204            _: (),
3205        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3206            ::fidl_next::munge! {
3207                let crate::wire::NodeDeprecatedGetAttrResponse {
3208                    s,
3209                    attributes,
3210
3211                } = out_;
3212            }
3213
3214            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3215
3216            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3217
3218            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
3219
3220            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3221
3222            Ok(())
3223        }
3224    }
3225
3226    unsafe impl<___E>
3227        ::fidl_next::EncodeOption<
3228            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3229            ___E,
3230        > for NodeDeprecatedGetAttrResponse
3231    where
3232        ___E: ::fidl_next::Encoder + ?Sized,
3233        NodeDeprecatedGetAttrResponse:
3234            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
3235    {
3236        #[inline]
3237        fn encode_option(
3238            this: ::core::option::Option<Self>,
3239            encoder: &mut ___E,
3240            out: &mut ::core::mem::MaybeUninit<
3241                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3242            >,
3243            _: (),
3244        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3245            if let Some(inner) = this {
3246                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3247                ::fidl_next::wire::Box::encode_present(out);
3248            } else {
3249                ::fidl_next::wire::Box::encode_absent(out);
3250            }
3251
3252            Ok(())
3253        }
3254    }
3255
3256    unsafe impl<'a, ___E>
3257        ::fidl_next::EncodeOption<
3258            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3259            ___E,
3260        > for &'a NodeDeprecatedGetAttrResponse
3261    where
3262        ___E: ::fidl_next::Encoder + ?Sized,
3263        &'a NodeDeprecatedGetAttrResponse:
3264            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>,
3265    {
3266        #[inline]
3267        fn encode_option(
3268            this: ::core::option::Option<Self>,
3269            encoder: &mut ___E,
3270            out: &mut ::core::mem::MaybeUninit<
3271                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetAttrResponse>,
3272            >,
3273            _: (),
3274        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3275            if let Some(inner) = this {
3276                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3277                ::fidl_next::wire::Box::encode_present(out);
3278            } else {
3279                ::fidl_next::wire::Box::encode_absent(out);
3280            }
3281
3282            Ok(())
3283        }
3284    }
3285
3286    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetAttrResponse>
3287        for NodeDeprecatedGetAttrResponse
3288    {
3289        #[inline]
3290        fn from_wire(wire: crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
3291            Self {
3292                s: ::fidl_next::FromWire::from_wire(wire.s),
3293
3294                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
3295            }
3296        }
3297    }
3298
3299    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetAttrResponse>
3300        for NodeDeprecatedGetAttrResponse
3301    {
3302        #[inline]
3303        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetAttrResponse) -> Self {
3304            Self {
3305                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
3306
3307                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
3308            }
3309        }
3310    }
3311
3312    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3313    pub struct NodeDeprecatedSetAttrRequest {
3314        pub flags: crate::natural::NodeAttributeFlags,
3315
3316        pub attributes: crate::natural::NodeAttributes,
3317    }
3318
3319    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
3320        for NodeDeprecatedSetAttrRequest
3321    where
3322        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3323    {
3324        #[inline]
3325        fn encode(
3326            self,
3327            encoder_: &mut ___E,
3328            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
3329            _: (),
3330        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3331            ::fidl_next::munge! {
3332                let crate::wire::NodeDeprecatedSetAttrRequest {
3333                    flags,
3334                    attributes,
3335
3336                } = out_;
3337            }
3338
3339            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3340
3341            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3342
3343            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
3344
3345            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3346
3347            Ok(())
3348        }
3349    }
3350
3351    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
3352        for &'a NodeDeprecatedSetAttrRequest
3353    where
3354        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3355    {
3356        #[inline]
3357        fn encode(
3358            self,
3359            encoder_: &mut ___E,
3360            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
3361            _: (),
3362        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3363            ::fidl_next::munge! {
3364                let crate::wire::NodeDeprecatedSetAttrRequest {
3365                    flags,
3366                    attributes,
3367
3368                } = out_;
3369            }
3370
3371            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3372
3373            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3374
3375            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, ())?;
3376
3377            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
3378
3379            Ok(())
3380        }
3381    }
3382
3383    unsafe impl<___E>
3384        ::fidl_next::EncodeOption<
3385            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3386            ___E,
3387        > for NodeDeprecatedSetAttrRequest
3388    where
3389        ___E: ::fidl_next::Encoder + ?Sized,
3390        NodeDeprecatedSetAttrRequest:
3391            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
3392    {
3393        #[inline]
3394        fn encode_option(
3395            this: ::core::option::Option<Self>,
3396            encoder: &mut ___E,
3397            out: &mut ::core::mem::MaybeUninit<
3398                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3399            >,
3400            _: (),
3401        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3402            if let Some(inner) = this {
3403                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3404                ::fidl_next::wire::Box::encode_present(out);
3405            } else {
3406                ::fidl_next::wire::Box::encode_absent(out);
3407            }
3408
3409            Ok(())
3410        }
3411    }
3412
3413    unsafe impl<'a, ___E>
3414        ::fidl_next::EncodeOption<
3415            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3416            ___E,
3417        > for &'a NodeDeprecatedSetAttrRequest
3418    where
3419        ___E: ::fidl_next::Encoder + ?Sized,
3420        &'a NodeDeprecatedSetAttrRequest:
3421            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>,
3422    {
3423        #[inline]
3424        fn encode_option(
3425            this: ::core::option::Option<Self>,
3426            encoder: &mut ___E,
3427            out: &mut ::core::mem::MaybeUninit<
3428                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrRequest>,
3429            >,
3430            _: (),
3431        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3432            if let Some(inner) = this {
3433                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3434                ::fidl_next::wire::Box::encode_present(out);
3435            } else {
3436                ::fidl_next::wire::Box::encode_absent(out);
3437            }
3438
3439            Ok(())
3440        }
3441    }
3442
3443    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrRequest>
3444        for NodeDeprecatedSetAttrRequest
3445    {
3446        #[inline]
3447        fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
3448            Self {
3449                flags: ::fidl_next::FromWire::from_wire(wire.flags),
3450
3451                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
3452            }
3453        }
3454    }
3455
3456    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrRequest>
3457        for NodeDeprecatedSetAttrRequest
3458    {
3459        #[inline]
3460        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrRequest) -> Self {
3461            Self {
3462                flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
3463
3464                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
3465            }
3466        }
3467    }
3468
3469    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3470    #[repr(C)]
3471    pub struct NodeDeprecatedSetAttrResponse {
3472        pub s: ::fidl_next::fuchsia::zx::Status,
3473    }
3474
3475    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
3476        for NodeDeprecatedSetAttrResponse
3477    where
3478        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3479    {
3480        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3481            Self,
3482            crate::wire::NodeDeprecatedSetAttrResponse,
3483        > = unsafe {
3484            ::fidl_next::CopyOptimization::enable_if(
3485                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
3486                    ::fidl_next::wire::fuchsia::Status,
3487                    ___E,
3488                >>::COPY_OPTIMIZATION
3489                    .is_enabled(),
3490            )
3491        };
3492
3493        #[inline]
3494        fn encode(
3495            self,
3496            encoder_: &mut ___E,
3497            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
3498            _: (),
3499        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3500            ::fidl_next::munge! {
3501                let crate::wire::NodeDeprecatedSetAttrResponse {
3502                    s,
3503
3504                } = out_;
3505            }
3506
3507            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3508
3509            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3510
3511            Ok(())
3512        }
3513    }
3514
3515    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
3516        for &'a NodeDeprecatedSetAttrResponse
3517    where
3518        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3519    {
3520        #[inline]
3521        fn encode(
3522            self,
3523            encoder_: &mut ___E,
3524            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
3525            _: (),
3526        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3527            ::fidl_next::munge! {
3528                let crate::wire::NodeDeprecatedSetAttrResponse {
3529                    s,
3530
3531                } = out_;
3532            }
3533
3534            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3535
3536            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3537
3538            Ok(())
3539        }
3540    }
3541
3542    unsafe impl<___E>
3543        ::fidl_next::EncodeOption<
3544            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3545            ___E,
3546        > for NodeDeprecatedSetAttrResponse
3547    where
3548        ___E: ::fidl_next::Encoder + ?Sized,
3549        NodeDeprecatedSetAttrResponse:
3550            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
3551    {
3552        #[inline]
3553        fn encode_option(
3554            this: ::core::option::Option<Self>,
3555            encoder: &mut ___E,
3556            out: &mut ::core::mem::MaybeUninit<
3557                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3558            >,
3559            _: (),
3560        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3561            if let Some(inner) = this {
3562                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3563                ::fidl_next::wire::Box::encode_present(out);
3564            } else {
3565                ::fidl_next::wire::Box::encode_absent(out);
3566            }
3567
3568            Ok(())
3569        }
3570    }
3571
3572    unsafe impl<'a, ___E>
3573        ::fidl_next::EncodeOption<
3574            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3575            ___E,
3576        > for &'a NodeDeprecatedSetAttrResponse
3577    where
3578        ___E: ::fidl_next::Encoder + ?Sized,
3579        &'a NodeDeprecatedSetAttrResponse:
3580            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>,
3581    {
3582        #[inline]
3583        fn encode_option(
3584            this: ::core::option::Option<Self>,
3585            encoder: &mut ___E,
3586            out: &mut ::core::mem::MaybeUninit<
3587                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetAttrResponse>,
3588            >,
3589            _: (),
3590        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3591            if let Some(inner) = this {
3592                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3593                ::fidl_next::wire::Box::encode_present(out);
3594            } else {
3595                ::fidl_next::wire::Box::encode_absent(out);
3596            }
3597
3598            Ok(())
3599        }
3600    }
3601
3602    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetAttrResponse>
3603        for NodeDeprecatedSetAttrResponse
3604    {
3605        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3606            crate::wire::NodeDeprecatedSetAttrResponse,
3607            Self,
3608        > = unsafe {
3609            ::fidl_next::CopyOptimization::enable_if(
3610                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
3611                    ::fidl_next::wire::fuchsia::Status,
3612                >>::COPY_OPTIMIZATION
3613                    .is_enabled(),
3614            )
3615        };
3616
3617        #[inline]
3618        fn from_wire(wire: crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
3619            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
3620        }
3621    }
3622
3623    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetAttrResponse>
3624        for NodeDeprecatedSetAttrResponse
3625    {
3626        #[inline]
3627        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetAttrResponse) -> Self {
3628            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
3629        }
3630    }
3631
3632    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3633    #[repr(C)]
3634    pub struct NodeDeprecatedGetFlagsResponse {
3635        pub s: ::fidl_next::fuchsia::zx::Status,
3636
3637        pub flags: crate::natural::OpenFlags,
3638    }
3639
3640    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
3641        for NodeDeprecatedGetFlagsResponse
3642    where
3643        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3644    {
3645        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3646            Self,
3647            crate::wire::NodeDeprecatedGetFlagsResponse,
3648        > = unsafe {
3649            ::fidl_next::CopyOptimization::enable_if(
3650                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
3651                    ::fidl_next::wire::fuchsia::Status,
3652                    ___E,
3653                >>::COPY_OPTIMIZATION
3654                    .is_enabled()
3655                    && <crate::natural::OpenFlags as ::fidl_next::Encode<
3656                        crate::wire::OpenFlags,
3657                        ___E,
3658                    >>::COPY_OPTIMIZATION
3659                        .is_enabled(),
3660            )
3661        };
3662
3663        #[inline]
3664        fn encode(
3665            self,
3666            encoder_: &mut ___E,
3667            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
3668            _: (),
3669        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3670            ::fidl_next::munge! {
3671                let crate::wire::NodeDeprecatedGetFlagsResponse {
3672                    s,
3673                    flags,
3674
3675                } = out_;
3676            }
3677
3678            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
3679
3680            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3681
3682            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3683
3684            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3685
3686            Ok(())
3687        }
3688    }
3689
3690    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
3691        for &'a NodeDeprecatedGetFlagsResponse
3692    where
3693        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3694    {
3695        #[inline]
3696        fn encode(
3697            self,
3698            encoder_: &mut ___E,
3699            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
3700            _: (),
3701        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3702            ::fidl_next::munge! {
3703                let crate::wire::NodeDeprecatedGetFlagsResponse {
3704                    s,
3705                    flags,
3706
3707                } = out_;
3708            }
3709
3710            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
3711
3712            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
3713
3714            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3715
3716            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3717
3718            Ok(())
3719        }
3720    }
3721
3722    unsafe impl<___E>
3723        ::fidl_next::EncodeOption<
3724            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3725            ___E,
3726        > for NodeDeprecatedGetFlagsResponse
3727    where
3728        ___E: ::fidl_next::Encoder + ?Sized,
3729        NodeDeprecatedGetFlagsResponse:
3730            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
3731    {
3732        #[inline]
3733        fn encode_option(
3734            this: ::core::option::Option<Self>,
3735            encoder: &mut ___E,
3736            out: &mut ::core::mem::MaybeUninit<
3737                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3738            >,
3739            _: (),
3740        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3741            if let Some(inner) = this {
3742                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3743                ::fidl_next::wire::Box::encode_present(out);
3744            } else {
3745                ::fidl_next::wire::Box::encode_absent(out);
3746            }
3747
3748            Ok(())
3749        }
3750    }
3751
3752    unsafe impl<'a, ___E>
3753        ::fidl_next::EncodeOption<
3754            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3755            ___E,
3756        > for &'a NodeDeprecatedGetFlagsResponse
3757    where
3758        ___E: ::fidl_next::Encoder + ?Sized,
3759        &'a NodeDeprecatedGetFlagsResponse:
3760            ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>,
3761    {
3762        #[inline]
3763        fn encode_option(
3764            this: ::core::option::Option<Self>,
3765            encoder: &mut ___E,
3766            out: &mut ::core::mem::MaybeUninit<
3767                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedGetFlagsResponse>,
3768            >,
3769            _: (),
3770        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3771            if let Some(inner) = this {
3772                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3773                ::fidl_next::wire::Box::encode_present(out);
3774            } else {
3775                ::fidl_next::wire::Box::encode_absent(out);
3776            }
3777
3778            Ok(())
3779        }
3780    }
3781
3782    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedGetFlagsResponse>
3783        for NodeDeprecatedGetFlagsResponse
3784    {
3785        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3786            crate::wire::NodeDeprecatedGetFlagsResponse,
3787            Self,
3788        > = unsafe {
3789            ::fidl_next::CopyOptimization::enable_if(
3790                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
3791                    ::fidl_next::wire::fuchsia::Status,
3792                >>::COPY_OPTIMIZATION
3793                    .is_enabled()
3794                    && <crate::natural::OpenFlags as ::fidl_next::FromWire<
3795                        crate::wire::OpenFlags,
3796                    >>::COPY_OPTIMIZATION
3797                        .is_enabled(),
3798            )
3799        };
3800
3801        #[inline]
3802        fn from_wire(wire: crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
3803            Self {
3804                s: ::fidl_next::FromWire::from_wire(wire.s),
3805
3806                flags: ::fidl_next::FromWire::from_wire(wire.flags),
3807            }
3808        }
3809    }
3810
3811    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedGetFlagsResponse>
3812        for NodeDeprecatedGetFlagsResponse
3813    {
3814        #[inline]
3815        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedGetFlagsResponse) -> Self {
3816            Self {
3817                s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s),
3818
3819                flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags),
3820            }
3821        }
3822    }
3823
3824    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3825    #[repr(C)]
3826    pub struct NodeDeprecatedSetFlagsRequest {
3827        pub flags: crate::natural::OpenFlags,
3828    }
3829
3830    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
3831        for NodeDeprecatedSetFlagsRequest
3832    where
3833        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3834    {
3835        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3836            Self,
3837            crate::wire::NodeDeprecatedSetFlagsRequest,
3838        > = unsafe {
3839            ::fidl_next::CopyOptimization::enable_if(
3840                true && <crate::natural::OpenFlags as ::fidl_next::Encode<
3841                    crate::wire::OpenFlags,
3842                    ___E,
3843                >>::COPY_OPTIMIZATION
3844                    .is_enabled(),
3845            )
3846        };
3847
3848        #[inline]
3849        fn encode(
3850            self,
3851            encoder_: &mut ___E,
3852            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
3853            _: (),
3854        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3855            ::fidl_next::munge! {
3856                let crate::wire::NodeDeprecatedSetFlagsRequest {
3857                    flags,
3858
3859                } = out_;
3860            }
3861
3862            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
3863
3864            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3865
3866            Ok(())
3867        }
3868    }
3869
3870    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
3871        for &'a NodeDeprecatedSetFlagsRequest
3872    where
3873        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3874    {
3875        #[inline]
3876        fn encode(
3877            self,
3878            encoder_: &mut ___E,
3879            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
3880            _: (),
3881        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3882            ::fidl_next::munge! {
3883                let crate::wire::NodeDeprecatedSetFlagsRequest {
3884                    flags,
3885
3886                } = out_;
3887            }
3888
3889            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
3890
3891            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
3892
3893            Ok(())
3894        }
3895    }
3896
3897    unsafe impl<___E>
3898        ::fidl_next::EncodeOption<
3899            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3900            ___E,
3901        > for NodeDeprecatedSetFlagsRequest
3902    where
3903        ___E: ::fidl_next::Encoder + ?Sized,
3904        NodeDeprecatedSetFlagsRequest:
3905            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
3906    {
3907        #[inline]
3908        fn encode_option(
3909            this: ::core::option::Option<Self>,
3910            encoder: &mut ___E,
3911            out: &mut ::core::mem::MaybeUninit<
3912                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3913            >,
3914            _: (),
3915        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3916            if let Some(inner) = this {
3917                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3918                ::fidl_next::wire::Box::encode_present(out);
3919            } else {
3920                ::fidl_next::wire::Box::encode_absent(out);
3921            }
3922
3923            Ok(())
3924        }
3925    }
3926
3927    unsafe impl<'a, ___E>
3928        ::fidl_next::EncodeOption<
3929            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3930            ___E,
3931        > for &'a NodeDeprecatedSetFlagsRequest
3932    where
3933        ___E: ::fidl_next::Encoder + ?Sized,
3934        &'a NodeDeprecatedSetFlagsRequest:
3935            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>,
3936    {
3937        #[inline]
3938        fn encode_option(
3939            this: ::core::option::Option<Self>,
3940            encoder: &mut ___E,
3941            out: &mut ::core::mem::MaybeUninit<
3942                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsRequest>,
3943            >,
3944            _: (),
3945        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3946            if let Some(inner) = this {
3947                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3948                ::fidl_next::wire::Box::encode_present(out);
3949            } else {
3950                ::fidl_next::wire::Box::encode_absent(out);
3951            }
3952
3953            Ok(())
3954        }
3955    }
3956
3957    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsRequest>
3958        for NodeDeprecatedSetFlagsRequest
3959    {
3960        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3961            crate::wire::NodeDeprecatedSetFlagsRequest,
3962            Self,
3963        > = unsafe {
3964            ::fidl_next::CopyOptimization::enable_if(
3965                true && <crate::natural::OpenFlags as ::fidl_next::FromWire<
3966                    crate::wire::OpenFlags,
3967                >>::COPY_OPTIMIZATION
3968                    .is_enabled(),
3969            )
3970        };
3971
3972        #[inline]
3973        fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
3974            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
3975        }
3976    }
3977
3978    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsRequest>
3979        for NodeDeprecatedSetFlagsRequest
3980    {
3981        #[inline]
3982        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsRequest) -> Self {
3983            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
3984        }
3985    }
3986
3987    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
3988    #[repr(C)]
3989    pub struct NodeDeprecatedSetFlagsResponse {
3990        pub s: ::fidl_next::fuchsia::zx::Status,
3991    }
3992
3993    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
3994        for NodeDeprecatedSetFlagsResponse
3995    where
3996        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3997    {
3998        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
3999            Self,
4000            crate::wire::NodeDeprecatedSetFlagsResponse,
4001        > = unsafe {
4002            ::fidl_next::CopyOptimization::enable_if(
4003                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::Encode<
4004                    ::fidl_next::wire::fuchsia::Status,
4005                    ___E,
4006                >>::COPY_OPTIMIZATION
4007                    .is_enabled(),
4008            )
4009        };
4010
4011        #[inline]
4012        fn encode(
4013            self,
4014            encoder_: &mut ___E,
4015            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
4016            _: (),
4017        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4018            ::fidl_next::munge! {
4019                let crate::wire::NodeDeprecatedSetFlagsResponse {
4020                    s,
4021
4022                } = out_;
4023            }
4024
4025            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
4026
4027            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4028
4029            Ok(())
4030        }
4031    }
4032
4033    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
4034        for &'a NodeDeprecatedSetFlagsResponse
4035    where
4036        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4037    {
4038        #[inline]
4039        fn encode(
4040            self,
4041            encoder_: &mut ___E,
4042            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
4043            _: (),
4044        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4045            ::fidl_next::munge! {
4046                let crate::wire::NodeDeprecatedSetFlagsResponse {
4047                    s,
4048
4049                } = out_;
4050            }
4051
4052            ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
4053
4054            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
4055
4056            Ok(())
4057        }
4058    }
4059
4060    unsafe impl<___E>
4061        ::fidl_next::EncodeOption<
4062            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4063            ___E,
4064        > for NodeDeprecatedSetFlagsResponse
4065    where
4066        ___E: ::fidl_next::Encoder + ?Sized,
4067        NodeDeprecatedSetFlagsResponse:
4068            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
4069    {
4070        #[inline]
4071        fn encode_option(
4072            this: ::core::option::Option<Self>,
4073            encoder: &mut ___E,
4074            out: &mut ::core::mem::MaybeUninit<
4075                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4076            >,
4077            _: (),
4078        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4079            if let Some(inner) = this {
4080                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4081                ::fidl_next::wire::Box::encode_present(out);
4082            } else {
4083                ::fidl_next::wire::Box::encode_absent(out);
4084            }
4085
4086            Ok(())
4087        }
4088    }
4089
4090    unsafe impl<'a, ___E>
4091        ::fidl_next::EncodeOption<
4092            ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4093            ___E,
4094        > for &'a NodeDeprecatedSetFlagsResponse
4095    where
4096        ___E: ::fidl_next::Encoder + ?Sized,
4097        &'a NodeDeprecatedSetFlagsResponse:
4098            ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>,
4099    {
4100        #[inline]
4101        fn encode_option(
4102            this: ::core::option::Option<Self>,
4103            encoder: &mut ___E,
4104            out: &mut ::core::mem::MaybeUninit<
4105                ::fidl_next::wire::Box<'static, crate::wire::NodeDeprecatedSetFlagsResponse>,
4106            >,
4107            _: (),
4108        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4109            if let Some(inner) = this {
4110                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4111                ::fidl_next::wire::Box::encode_present(out);
4112            } else {
4113                ::fidl_next::wire::Box::encode_absent(out);
4114            }
4115
4116            Ok(())
4117        }
4118    }
4119
4120    impl ::fidl_next::FromWire<crate::wire::NodeDeprecatedSetFlagsResponse>
4121        for NodeDeprecatedSetFlagsResponse
4122    {
4123        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4124            crate::wire::NodeDeprecatedSetFlagsResponse,
4125            Self,
4126        > = unsafe {
4127            ::fidl_next::CopyOptimization::enable_if(
4128                true && <::fidl_next::fuchsia::zx::Status as ::fidl_next::FromWire<
4129                    ::fidl_next::wire::fuchsia::Status,
4130                >>::COPY_OPTIMIZATION
4131                    .is_enabled(),
4132            )
4133        };
4134
4135        #[inline]
4136        fn from_wire(wire: crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
4137            Self { s: ::fidl_next::FromWire::from_wire(wire.s) }
4138        }
4139    }
4140
4141    impl ::fidl_next::FromWireRef<crate::wire::NodeDeprecatedSetFlagsResponse>
4142        for NodeDeprecatedSetFlagsResponse
4143    {
4144        #[inline]
4145        fn from_wire_ref(wire: &crate::wire::NodeDeprecatedSetFlagsResponse) -> Self {
4146            Self { s: ::fidl_next::FromWireRef::from_wire_ref(&wire.s) }
4147        }
4148    }
4149
4150    ::fidl_next::bitflags::bitflags! {
4151        #[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 {
4152            #[doc = " Allows opening child nodes with [`PROTOCOL_SERVICE`].\n"]const PERM_CONNECT = 1;
4153            #[doc = " Read byte contents of a file.\n"]const PERM_READ_BYTES = 2;
4154            #[doc = " Write byte contents to a file.\n"]const PERM_WRITE_BYTES = 4;
4155            #[doc = " Execute byte contents of a file.\n"]const PERM_EXECUTE = 8;
4156            #[doc = " Get/query attributes of a node.\n"]const PERM_GET_ATTRIBUTES = 16;
4157            #[doc = " Set/update attributes of a node.\n"]const PERM_UPDATE_ATTRIBUTES = 32;
4158            #[doc = " Enumerate (list) directory entries.\n"]const PERM_ENUMERATE = 64;
4159            #[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;
4160            #[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;
4161            #[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;
4162            #[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;
4163            #[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;
4164            #[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;
4165            #[doc = " Caller accepts [`fuchsia.io/Directory`] protocol. Equivalent to POSIX `O_DIRECTORY`.\n"]const PROTOCOL_DIRECTORY = 524288;
4166            #[doc = " Caller accepts [`fuchsia.io/File`] protocol.\n"]const PROTOCOL_FILE = 8589934592;
4167            #[doc = " Caller accepts [`fuchsia.io/Symlink`] protocol.\n"]const PROTOCOL_SYMLINK = 17179869184;
4168            #[doc = " Caller requests a [`fuchsia.io/Node.OnRepresentation`] event on success.\n"]const FLAG_SEND_REPRESENTATION = 1099511627776;
4169            #[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;
4170            #[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;
4171            #[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;
4172            #[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;
4173            #[doc = " Truncate the file to zero length upon opening it. Equivalent to POSIX `O_TRUNC`.\n"]const FILE_TRUNCATE = 262144;
4174            const _ = !0;
4175        }
4176    }
4177
4178    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for Flags
4179    where
4180        ___E: ?Sized,
4181    {
4182        #[inline]
4183        fn encode(
4184            self,
4185            encoder: &mut ___E,
4186            out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
4187            _: (),
4188        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4189            ::fidl_next::Encode::encode(&self, encoder, out, ())
4190        }
4191    }
4192
4193    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Flags, ___E> for &'a Flags
4194    where
4195        ___E: ?Sized,
4196    {
4197        #[inline]
4198        fn encode(
4199            self,
4200            _: &mut ___E,
4201            out: &mut ::core::mem::MaybeUninit<crate::wire::Flags>,
4202            _: (),
4203        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4204            ::fidl_next::munge!(let crate::wire::Flags { value } = out);
4205
4206            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
4207            Ok(())
4208        }
4209    }
4210
4211    impl ::core::convert::From<crate::wire::Flags> for Flags {
4212        fn from(wire: crate::wire::Flags) -> Self {
4213            Self::from_bits_retain(u64::from(wire.value))
4214        }
4215    }
4216
4217    impl ::fidl_next::FromWire<crate::wire::Flags> for Flags {
4218        #[inline]
4219        fn from_wire(wire: crate::wire::Flags) -> Self {
4220            Self::from(wire)
4221        }
4222    }
4223
4224    impl ::fidl_next::FromWireRef<crate::wire::Flags> for Flags {
4225        #[inline]
4226        fn from_wire_ref(wire: &crate::wire::Flags) -> Self {
4227            Self::from(*wire)
4228        }
4229    }
4230
4231    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4232    #[repr(C)]
4233    pub struct NodeGetFlagsResponse {
4234        pub flags: crate::natural::Flags,
4235    }
4236
4237    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
4238        for NodeGetFlagsResponse
4239    where
4240        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4241    {
4242        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4243            Self,
4244            crate::wire::NodeGetFlagsResponse,
4245        > = unsafe {
4246            ::fidl_next::CopyOptimization::enable_if(
4247            true
4248
4249                && <
4250                    crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
4251                >::COPY_OPTIMIZATION.is_enabled()
4252
4253        )
4254        };
4255
4256        #[inline]
4257        fn encode(
4258            self,
4259            encoder_: &mut ___E,
4260            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
4261            _: (),
4262        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4263            ::fidl_next::munge! {
4264                let crate::wire::NodeGetFlagsResponse {
4265                    flags,
4266
4267                } = out_;
4268            }
4269
4270            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4271
4272            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4273
4274            Ok(())
4275        }
4276    }
4277
4278    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
4279        for &'a NodeGetFlagsResponse
4280    where
4281        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4282    {
4283        #[inline]
4284        fn encode(
4285            self,
4286            encoder_: &mut ___E,
4287            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
4288            _: (),
4289        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4290            ::fidl_next::munge! {
4291                let crate::wire::NodeGetFlagsResponse {
4292                    flags,
4293
4294                } = out_;
4295            }
4296
4297            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4298
4299            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4300
4301            Ok(())
4302        }
4303    }
4304
4305    unsafe impl<___E>
4306        ::fidl_next::EncodeOption<
4307            ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4308            ___E,
4309        > for NodeGetFlagsResponse
4310    where
4311        ___E: ::fidl_next::Encoder + ?Sized,
4312        NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
4313    {
4314        #[inline]
4315        fn encode_option(
4316            this: ::core::option::Option<Self>,
4317            encoder: &mut ___E,
4318            out: &mut ::core::mem::MaybeUninit<
4319                ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4320            >,
4321            _: (),
4322        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4323            if let Some(inner) = this {
4324                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4325                ::fidl_next::wire::Box::encode_present(out);
4326            } else {
4327                ::fidl_next::wire::Box::encode_absent(out);
4328            }
4329
4330            Ok(())
4331        }
4332    }
4333
4334    unsafe impl<'a, ___E>
4335        ::fidl_next::EncodeOption<
4336            ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4337            ___E,
4338        > for &'a NodeGetFlagsResponse
4339    where
4340        ___E: ::fidl_next::Encoder + ?Sized,
4341        &'a NodeGetFlagsResponse: ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>,
4342    {
4343        #[inline]
4344        fn encode_option(
4345            this: ::core::option::Option<Self>,
4346            encoder: &mut ___E,
4347            out: &mut ::core::mem::MaybeUninit<
4348                ::fidl_next::wire::Box<'static, crate::wire::NodeGetFlagsResponse>,
4349            >,
4350            _: (),
4351        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4352            if let Some(inner) = this {
4353                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4354                ::fidl_next::wire::Box::encode_present(out);
4355            } else {
4356                ::fidl_next::wire::Box::encode_absent(out);
4357            }
4358
4359            Ok(())
4360        }
4361    }
4362
4363    impl ::fidl_next::FromWire<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
4364        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4365            crate::wire::NodeGetFlagsResponse,
4366            Self,
4367        > = unsafe {
4368            ::fidl_next::CopyOptimization::enable_if(
4369            true
4370
4371                && <
4372                    crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
4373                >::COPY_OPTIMIZATION.is_enabled()
4374
4375        )
4376        };
4377
4378        #[inline]
4379        fn from_wire(wire: crate::wire::NodeGetFlagsResponse) -> Self {
4380            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
4381        }
4382    }
4383
4384    impl ::fidl_next::FromWireRef<crate::wire::NodeGetFlagsResponse> for NodeGetFlagsResponse {
4385        #[inline]
4386        fn from_wire_ref(wire: &crate::wire::NodeGetFlagsResponse) -> Self {
4387            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
4388        }
4389    }
4390
4391    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4392    #[repr(C)]
4393    pub struct NodeSetFlagsRequest {
4394        pub flags: crate::natural::Flags,
4395    }
4396
4397    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
4398        for NodeSetFlagsRequest
4399    where
4400        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4401    {
4402        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4403            Self,
4404            crate::wire::NodeSetFlagsRequest,
4405        > = unsafe {
4406            ::fidl_next::CopyOptimization::enable_if(
4407            true
4408
4409                && <
4410                    crate::natural::Flags as ::fidl_next::Encode<crate::wire::Flags, ___E>
4411                >::COPY_OPTIMIZATION.is_enabled()
4412
4413        )
4414        };
4415
4416        #[inline]
4417        fn encode(
4418            self,
4419            encoder_: &mut ___E,
4420            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
4421            _: (),
4422        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4423            ::fidl_next::munge! {
4424                let crate::wire::NodeSetFlagsRequest {
4425                    flags,
4426
4427                } = out_;
4428            }
4429
4430            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
4431
4432            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4433
4434            Ok(())
4435        }
4436    }
4437
4438    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
4439        for &'a NodeSetFlagsRequest
4440    where
4441        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4442    {
4443        #[inline]
4444        fn encode(
4445            self,
4446            encoder_: &mut ___E,
4447            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
4448            _: (),
4449        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4450            ::fidl_next::munge! {
4451                let crate::wire::NodeSetFlagsRequest {
4452                    flags,
4453
4454                } = out_;
4455            }
4456
4457            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
4458
4459            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
4460
4461            Ok(())
4462        }
4463    }
4464
4465    unsafe impl<___E>
4466        ::fidl_next::EncodeOption<
4467            ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4468            ___E,
4469        > for NodeSetFlagsRequest
4470    where
4471        ___E: ::fidl_next::Encoder + ?Sized,
4472        NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
4473    {
4474        #[inline]
4475        fn encode_option(
4476            this: ::core::option::Option<Self>,
4477            encoder: &mut ___E,
4478            out: &mut ::core::mem::MaybeUninit<
4479                ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4480            >,
4481            _: (),
4482        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4483            if let Some(inner) = this {
4484                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4485                ::fidl_next::wire::Box::encode_present(out);
4486            } else {
4487                ::fidl_next::wire::Box::encode_absent(out);
4488            }
4489
4490            Ok(())
4491        }
4492    }
4493
4494    unsafe impl<'a, ___E>
4495        ::fidl_next::EncodeOption<
4496            ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4497            ___E,
4498        > for &'a NodeSetFlagsRequest
4499    where
4500        ___E: ::fidl_next::Encoder + ?Sized,
4501        &'a NodeSetFlagsRequest: ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>,
4502    {
4503        #[inline]
4504        fn encode_option(
4505            this: ::core::option::Option<Self>,
4506            encoder: &mut ___E,
4507            out: &mut ::core::mem::MaybeUninit<
4508                ::fidl_next::wire::Box<'static, crate::wire::NodeSetFlagsRequest>,
4509            >,
4510            _: (),
4511        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4512            if let Some(inner) = this {
4513                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
4514                ::fidl_next::wire::Box::encode_present(out);
4515            } else {
4516                ::fidl_next::wire::Box::encode_absent(out);
4517            }
4518
4519            Ok(())
4520        }
4521    }
4522
4523    impl ::fidl_next::FromWire<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
4524        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
4525            crate::wire::NodeSetFlagsRequest,
4526            Self,
4527        > = unsafe {
4528            ::fidl_next::CopyOptimization::enable_if(
4529            true
4530
4531                && <
4532                    crate::natural::Flags as ::fidl_next::FromWire<crate::wire::Flags>
4533                >::COPY_OPTIMIZATION.is_enabled()
4534
4535        )
4536        };
4537
4538        #[inline]
4539        fn from_wire(wire: crate::wire::NodeSetFlagsRequest) -> Self {
4540            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
4541        }
4542    }
4543
4544    impl ::fidl_next::FromWireRef<crate::wire::NodeSetFlagsRequest> for NodeSetFlagsRequest {
4545        #[inline]
4546        fn from_wire_ref(wire: &crate::wire::NodeSetFlagsRequest) -> Self {
4547            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
4548        }
4549    }
4550
4551    #[doc = " Used in places where empty structs are needed, such as empty union members, to avoid creating\n new struct types.\n"]
4552    pub type EmptyStruct = ();
4553
4554    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4555    pub enum SelinuxContext {
4556        Data(::std::vec::Vec<u8>),
4557
4558        UseExtendedAttributes(crate::natural::EmptyStruct),
4559
4560        UnknownOrdinal_(u64),
4561    }
4562
4563    impl SelinuxContext {
4564        pub fn is_unknown(&self) -> bool {
4565            #[allow(unreachable_patterns)]
4566            match self {
4567                Self::UnknownOrdinal_(_) => true,
4568                _ => false,
4569            }
4570        }
4571    }
4572
4573    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E> for SelinuxContext
4574    where
4575        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4576        ___E: ::fidl_next::Encoder,
4577    {
4578        #[inline]
4579        fn encode(
4580            self,
4581            encoder: &mut ___E,
4582            out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
4583            _: (),
4584        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4585            ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
4586
4587            match self {
4588                Self::Data(value) => ::fidl_next::wire::Union::encode_as::<
4589                    ___E,
4590                    ::fidl_next::wire::Vector<'static, u8>,
4591                >(value, 1, encoder, raw, (256, ()))?,
4592
4593                Self::UseExtendedAttributes(value) => ::fidl_next::wire::Union::encode_as::<
4594                    ___E,
4595                    crate::wire::EmptyStruct,
4596                >(value, 2, encoder, raw, ())?,
4597
4598                Self::UnknownOrdinal_(ordinal) => {
4599                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
4600                }
4601            }
4602
4603            Ok(())
4604        }
4605    }
4606
4607    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>
4608        for &'a SelinuxContext
4609    where
4610        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4611        ___E: ::fidl_next::Encoder,
4612    {
4613        #[inline]
4614        fn encode(
4615            self,
4616            encoder: &mut ___E,
4617            out: &mut ::core::mem::MaybeUninit<crate::wire::SelinuxContext<'static>>,
4618            _: (),
4619        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4620            ::fidl_next::munge!(let crate::wire::SelinuxContext { raw, _phantom: _ } = out);
4621
4622            match self {
4623                SelinuxContext::Data(value) => ::fidl_next::wire::Union::encode_as::<
4624                    ___E,
4625                    ::fidl_next::wire::Vector<'static, u8>,
4626                >(value, 1, encoder, raw, (256, ()))?,
4627
4628                SelinuxContext::UseExtendedAttributes(value) => {
4629                    ::fidl_next::wire::Union::encode_as::<___E, crate::wire::EmptyStruct>(
4630                        value,
4631                        2,
4632                        encoder,
4633                        raw,
4634                        (),
4635                    )?
4636                }
4637
4638                SelinuxContext::UnknownOrdinal_(ordinal) => {
4639                    return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(*ordinal as usize));
4640                }
4641            }
4642
4643            Ok(())
4644        }
4645    }
4646
4647    unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
4648        for SelinuxContext
4649    where
4650        ___E: ?Sized,
4651        SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
4652    {
4653        #[inline]
4654        fn encode_option(
4655            this: ::core::option::Option<Self>,
4656            encoder: &mut ___E,
4657            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
4658            _: (),
4659        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4660            ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
4661
4662            if let Some(inner) = this {
4663                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4664                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4665            } else {
4666                ::fidl_next::wire::Union::encode_absent(raw);
4667            }
4668
4669            Ok(())
4670        }
4671    }
4672
4673    unsafe impl<'a, ___E>
4674        ::fidl_next::EncodeOption<crate::wire_optional::SelinuxContext<'static>, ___E>
4675        for &'a SelinuxContext
4676    where
4677        ___E: ?Sized,
4678        &'a SelinuxContext: ::fidl_next::Encode<crate::wire::SelinuxContext<'static>, ___E>,
4679    {
4680        #[inline]
4681        fn encode_option(
4682            this: ::core::option::Option<Self>,
4683            encoder: &mut ___E,
4684            out: &mut ::core::mem::MaybeUninit<crate::wire_optional::SelinuxContext<'static>>,
4685            _: (),
4686        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4687            ::fidl_next::munge!(let crate::wire_optional::SelinuxContext { raw, _phantom: _ } = &mut *out);
4688
4689            if let Some(inner) = this {
4690                let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
4691                ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
4692            } else {
4693                ::fidl_next::wire::Union::encode_absent(raw);
4694            }
4695
4696            Ok(())
4697        }
4698    }
4699
4700    impl<'de> ::fidl_next::FromWire<crate::wire::SelinuxContext<'de>> for SelinuxContext {
4701        #[inline]
4702        fn from_wire(wire: crate::wire::SelinuxContext<'de>) -> Self {
4703            let wire = ::core::mem::ManuallyDrop::new(wire);
4704            match wire.raw.ordinal() {
4705                1 => Self::Data(::fidl_next::FromWire::from_wire(unsafe {
4706                    wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
4707                })),
4708
4709                2 => Self::UseExtendedAttributes(::fidl_next::FromWire::from_wire(unsafe {
4710                    wire.raw.get().read_unchecked::<crate::wire::EmptyStruct>()
4711                })),
4712
4713                ord => return Self::UnknownOrdinal_(ord as u64),
4714            }
4715        }
4716    }
4717
4718    impl<'de> ::fidl_next::FromWireRef<crate::wire::SelinuxContext<'de>> for SelinuxContext {
4719        #[inline]
4720        fn from_wire_ref(wire: &crate::wire::SelinuxContext<'de>) -> Self {
4721            match wire.raw.ordinal() {
4722                1 => Self::Data(::fidl_next::FromWireRef::from_wire_ref(unsafe {
4723                    wire.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
4724                })),
4725
4726                2 => Self::UseExtendedAttributes(::fidl_next::FromWireRef::from_wire_ref(unsafe {
4727                    wire.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
4728                })),
4729
4730                ord => return Self::UnknownOrdinal_(ord as u64),
4731            }
4732        }
4733    }
4734
4735    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
4736        for SelinuxContext
4737    {
4738        #[inline]
4739        fn from_wire_option(
4740            wire: crate::wire_optional::SelinuxContext<'de>,
4741        ) -> ::core::option::Option<Self> {
4742            if let Some(inner) = wire.into_option() {
4743                Some(::fidl_next::FromWire::from_wire(inner))
4744            } else {
4745                None
4746            }
4747        }
4748    }
4749
4750    impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::SelinuxContext<'de>>
4751        for Box<SelinuxContext>
4752    {
4753        #[inline]
4754        fn from_wire_option(
4755            wire: crate::wire_optional::SelinuxContext<'de>,
4756        ) -> ::core::option::Option<Self> {
4757            <SelinuxContext as ::fidl_next::FromWireOption<
4758                crate::wire_optional::SelinuxContext<'de>,
4759            >>::from_wire_option(wire)
4760            .map(Box::new)
4761        }
4762    }
4763
4764    impl<'de> ::fidl_next::FromWireOptionRef<crate::wire_optional::SelinuxContext<'de>>
4765        for Box<SelinuxContext>
4766    {
4767        #[inline]
4768        fn from_wire_option_ref(
4769            wire: &crate::wire_optional::SelinuxContext<'de>,
4770        ) -> ::core::option::Option<Self> {
4771            if let Some(inner) = wire.as_ref() {
4772                Some(Box::new(::fidl_next::FromWireRef::from_wire_ref(inner)))
4773            } else {
4774                None
4775            }
4776        }
4777    }
4778
4779    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
4780    pub struct MutableNodeAttributes {
4781        pub creation_time: ::core::option::Option<u64>,
4782
4783        pub modification_time: ::core::option::Option<u64>,
4784
4785        pub mode: ::core::option::Option<u32>,
4786
4787        pub uid: ::core::option::Option<u32>,
4788
4789        pub gid: ::core::option::Option<u32>,
4790
4791        pub rdev: ::core::option::Option<u64>,
4792
4793        pub access_time: ::core::option::Option<u64>,
4794
4795        pub casefold: ::core::option::Option<bool>,
4796
4797        pub selinux_context: ::core::option::Option<crate::natural::SelinuxContext>,
4798
4799        pub wrapping_key_id: ::core::option::Option<[u8; 16]>,
4800    }
4801
4802    impl MutableNodeAttributes {
4803        fn __max_ordinal(&self) -> usize {
4804            if self.wrapping_key_id.is_some() {
4805                return 10;
4806            }
4807
4808            if self.selinux_context.is_some() {
4809                return 9;
4810            }
4811
4812            if self.casefold.is_some() {
4813                return 8;
4814            }
4815
4816            if self.access_time.is_some() {
4817                return 7;
4818            }
4819
4820            if self.rdev.is_some() {
4821                return 6;
4822            }
4823
4824            if self.gid.is_some() {
4825                return 5;
4826            }
4827
4828            if self.uid.is_some() {
4829                return 4;
4830            }
4831
4832            if self.mode.is_some() {
4833                return 3;
4834            }
4835
4836            if self.modification_time.is_some() {
4837                return 2;
4838            }
4839
4840            if self.creation_time.is_some() {
4841                return 1;
4842            }
4843
4844            0
4845        }
4846    }
4847
4848    unsafe impl<___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
4849        for MutableNodeAttributes
4850    where
4851        ___E: ::fidl_next::Encoder + ?Sized,
4852    {
4853        #[inline]
4854        fn encode(
4855            mut self,
4856            encoder: &mut ___E,
4857            out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
4858            _: (),
4859        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4860            ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
4861
4862            let max_ord = self.__max_ordinal();
4863
4864            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
4865            ::fidl_next::Wire::zero_padding(&mut out);
4866
4867            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
4868                ::fidl_next::wire::Envelope,
4869            >(encoder, max_ord);
4870
4871            for i in 1..=max_ord {
4872                match i {
4873                    10 => {
4874                        if let Some(value) = self.wrapping_key_id.take() {
4875                            ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
4876                                value,
4877                                preallocated.encoder,
4878                                &mut out,
4879                                (),
4880                            )?;
4881                        } else {
4882                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4883                        }
4884                    }
4885
4886                    9 => {
4887                        if let Some(value) = self.selinux_context.take() {
4888                            ::fidl_next::wire::Envelope::encode_value::<
4889                                crate::wire::SelinuxContext<'static>,
4890                                ___E,
4891                            >(
4892                                value, preallocated.encoder, &mut out, ()
4893                            )?;
4894                        } else {
4895                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4896                        }
4897                    }
4898
4899                    8 => {
4900                        if let Some(value) = self.casefold.take() {
4901                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
4902                                value,
4903                                preallocated.encoder,
4904                                &mut out,
4905                                (),
4906                            )?;
4907                        } else {
4908                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4909                        }
4910                    }
4911
4912                    7 => {
4913                        if let Some(value) = self.access_time.take() {
4914                            ::fidl_next::wire::Envelope::encode_value::<
4915                                ::fidl_next::wire::Uint64,
4916                                ___E,
4917                            >(
4918                                value, preallocated.encoder, &mut out, ()
4919                            )?;
4920                        } else {
4921                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4922                        }
4923                    }
4924
4925                    6 => {
4926                        if let Some(value) = self.rdev.take() {
4927                            ::fidl_next::wire::Envelope::encode_value::<
4928                                ::fidl_next::wire::Uint64,
4929                                ___E,
4930                            >(
4931                                value, preallocated.encoder, &mut out, ()
4932                            )?;
4933                        } else {
4934                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4935                        }
4936                    }
4937
4938                    5 => {
4939                        if let Some(value) = self.gid.take() {
4940                            ::fidl_next::wire::Envelope::encode_value::<
4941                                ::fidl_next::wire::Uint32,
4942                                ___E,
4943                            >(
4944                                value, preallocated.encoder, &mut out, ()
4945                            )?;
4946                        } else {
4947                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4948                        }
4949                    }
4950
4951                    4 => {
4952                        if let Some(value) = self.uid.take() {
4953                            ::fidl_next::wire::Envelope::encode_value::<
4954                                ::fidl_next::wire::Uint32,
4955                                ___E,
4956                            >(
4957                                value, preallocated.encoder, &mut out, ()
4958                            )?;
4959                        } else {
4960                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4961                        }
4962                    }
4963
4964                    3 => {
4965                        if let Some(value) = self.mode.take() {
4966                            ::fidl_next::wire::Envelope::encode_value::<
4967                                ::fidl_next::wire::Uint32,
4968                                ___E,
4969                            >(
4970                                value, preallocated.encoder, &mut out, ()
4971                            )?;
4972                        } else {
4973                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4974                        }
4975                    }
4976
4977                    2 => {
4978                        if let Some(value) = self.modification_time.take() {
4979                            ::fidl_next::wire::Envelope::encode_value::<
4980                                ::fidl_next::wire::Uint64,
4981                                ___E,
4982                            >(
4983                                value, preallocated.encoder, &mut out, ()
4984                            )?;
4985                        } else {
4986                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
4987                        }
4988                    }
4989
4990                    1 => {
4991                        if let Some(value) = self.creation_time.take() {
4992                            ::fidl_next::wire::Envelope::encode_value::<
4993                                ::fidl_next::wire::Uint64,
4994                                ___E,
4995                            >(
4996                                value, preallocated.encoder, &mut out, ()
4997                            )?;
4998                        } else {
4999                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5000                        }
5001                    }
5002
5003                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5004                }
5005                unsafe {
5006                    preallocated.write_next(out.assume_init_ref());
5007                }
5008            }
5009
5010            ::fidl_next::wire::Table::encode_len(table, max_ord);
5011
5012            Ok(())
5013        }
5014    }
5015
5016    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>
5017        for &'a MutableNodeAttributes
5018    where
5019        ___E: ::fidl_next::Encoder + ?Sized,
5020    {
5021        #[inline]
5022        fn encode(
5023            self,
5024            encoder: &mut ___E,
5025            out: &mut ::core::mem::MaybeUninit<crate::wire::MutableNodeAttributes<'static>>,
5026            _: (),
5027        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5028            ::fidl_next::munge!(let crate::wire::MutableNodeAttributes { table } = out);
5029
5030            let max_ord = self.__max_ordinal();
5031
5032            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5033            ::fidl_next::Wire::zero_padding(&mut out);
5034
5035            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5036                ::fidl_next::wire::Envelope,
5037            >(encoder, max_ord);
5038
5039            for i in 1..=max_ord {
5040                match i {
5041                    10 => {
5042                        if let Some(value) = &self.wrapping_key_id {
5043                            ::fidl_next::wire::Envelope::encode_value::<[u8; 16], ___E>(
5044                                value,
5045                                preallocated.encoder,
5046                                &mut out,
5047                                (),
5048                            )?;
5049                        } else {
5050                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5051                        }
5052                    }
5053
5054                    9 => {
5055                        if let Some(value) = &self.selinux_context {
5056                            ::fidl_next::wire::Envelope::encode_value::<
5057                                crate::wire::SelinuxContext<'static>,
5058                                ___E,
5059                            >(
5060                                value, preallocated.encoder, &mut out, ()
5061                            )?;
5062                        } else {
5063                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5064                        }
5065                    }
5066
5067                    8 => {
5068                        if let Some(value) = &self.casefold {
5069                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5070                                value,
5071                                preallocated.encoder,
5072                                &mut out,
5073                                (),
5074                            )?;
5075                        } else {
5076                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5077                        }
5078                    }
5079
5080                    7 => {
5081                        if let Some(value) = &self.access_time {
5082                            ::fidl_next::wire::Envelope::encode_value::<
5083                                ::fidl_next::wire::Uint64,
5084                                ___E,
5085                            >(
5086                                value, preallocated.encoder, &mut out, ()
5087                            )?;
5088                        } else {
5089                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5090                        }
5091                    }
5092
5093                    6 => {
5094                        if let Some(value) = &self.rdev {
5095                            ::fidl_next::wire::Envelope::encode_value::<
5096                                ::fidl_next::wire::Uint64,
5097                                ___E,
5098                            >(
5099                                value, preallocated.encoder, &mut out, ()
5100                            )?;
5101                        } else {
5102                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5103                        }
5104                    }
5105
5106                    5 => {
5107                        if let Some(value) = &self.gid {
5108                            ::fidl_next::wire::Envelope::encode_value::<
5109                                ::fidl_next::wire::Uint32,
5110                                ___E,
5111                            >(
5112                                value, preallocated.encoder, &mut out, ()
5113                            )?;
5114                        } else {
5115                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5116                        }
5117                    }
5118
5119                    4 => {
5120                        if let Some(value) = &self.uid {
5121                            ::fidl_next::wire::Envelope::encode_value::<
5122                                ::fidl_next::wire::Uint32,
5123                                ___E,
5124                            >(
5125                                value, preallocated.encoder, &mut out, ()
5126                            )?;
5127                        } else {
5128                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5129                        }
5130                    }
5131
5132                    3 => {
5133                        if let Some(value) = &self.mode {
5134                            ::fidl_next::wire::Envelope::encode_value::<
5135                                ::fidl_next::wire::Uint32,
5136                                ___E,
5137                            >(
5138                                value, preallocated.encoder, &mut out, ()
5139                            )?;
5140                        } else {
5141                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5142                        }
5143                    }
5144
5145                    2 => {
5146                        if let Some(value) = &self.modification_time {
5147                            ::fidl_next::wire::Envelope::encode_value::<
5148                                ::fidl_next::wire::Uint64,
5149                                ___E,
5150                            >(
5151                                value, preallocated.encoder, &mut out, ()
5152                            )?;
5153                        } else {
5154                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5155                        }
5156                    }
5157
5158                    1 => {
5159                        if let Some(value) = &self.creation_time {
5160                            ::fidl_next::wire::Envelope::encode_value::<
5161                                ::fidl_next::wire::Uint64,
5162                                ___E,
5163                            >(
5164                                value, preallocated.encoder, &mut out, ()
5165                            )?;
5166                        } else {
5167                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5168                        }
5169                    }
5170
5171                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5172                }
5173                unsafe {
5174                    preallocated.write_next(out.assume_init_ref());
5175                }
5176            }
5177
5178            ::fidl_next::wire::Table::encode_len(table, max_ord);
5179
5180            Ok(())
5181        }
5182    }
5183
5184    impl<'de> ::fidl_next::FromWire<crate::wire::MutableNodeAttributes<'de>> for MutableNodeAttributes {
5185        #[inline]
5186        fn from_wire(wire_: crate::wire::MutableNodeAttributes<'de>) -> Self {
5187            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5188
5189            let creation_time = wire_.table.get(1);
5190
5191            let modification_time = wire_.table.get(2);
5192
5193            let mode = wire_.table.get(3);
5194
5195            let uid = wire_.table.get(4);
5196
5197            let gid = wire_.table.get(5);
5198
5199            let rdev = wire_.table.get(6);
5200
5201            let access_time = wire_.table.get(7);
5202
5203            let casefold = wire_.table.get(8);
5204
5205            let selinux_context = wire_.table.get(9);
5206
5207            let wrapping_key_id = wire_.table.get(10);
5208
5209            Self {
5210                creation_time: creation_time.map(|envelope| {
5211                    ::fidl_next::FromWire::from_wire(unsafe {
5212                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5213                    })
5214                }),
5215
5216                modification_time: modification_time.map(|envelope| {
5217                    ::fidl_next::FromWire::from_wire(unsafe {
5218                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5219                    })
5220                }),
5221
5222                mode: mode.map(|envelope| {
5223                    ::fidl_next::FromWire::from_wire(unsafe {
5224                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5225                    })
5226                }),
5227
5228                uid: uid.map(|envelope| {
5229                    ::fidl_next::FromWire::from_wire(unsafe {
5230                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5231                    })
5232                }),
5233
5234                gid: gid.map(|envelope| {
5235                    ::fidl_next::FromWire::from_wire(unsafe {
5236                        envelope.read_unchecked::<::fidl_next::wire::Uint32>()
5237                    })
5238                }),
5239
5240                rdev: rdev.map(|envelope| {
5241                    ::fidl_next::FromWire::from_wire(unsafe {
5242                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5243                    })
5244                }),
5245
5246                access_time: access_time.map(|envelope| {
5247                    ::fidl_next::FromWire::from_wire(unsafe {
5248                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
5249                    })
5250                }),
5251
5252                casefold: casefold.map(|envelope| {
5253                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
5254                }),
5255
5256                selinux_context: selinux_context.map(|envelope| {
5257                    ::fidl_next::FromWire::from_wire(unsafe {
5258                        envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
5259                    })
5260                }),
5261
5262                wrapping_key_id: wrapping_key_id.map(|envelope| {
5263                    ::fidl_next::FromWire::from_wire(unsafe {
5264                        envelope.read_unchecked::<[u8; 16]>()
5265                    })
5266                }),
5267            }
5268        }
5269    }
5270
5271    impl<'de> ::fidl_next::FromWireRef<crate::wire::MutableNodeAttributes<'de>>
5272        for MutableNodeAttributes
5273    {
5274        #[inline]
5275        fn from_wire_ref(wire: &crate::wire::MutableNodeAttributes<'de>) -> Self {
5276            Self {
5277                creation_time: wire.table.get(1).map(|envelope| {
5278                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5279                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5280                    })
5281                }),
5282
5283                modification_time: wire.table.get(2).map(|envelope| {
5284                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5285                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5286                    })
5287                }),
5288
5289                mode: wire.table.get(3).map(|envelope| {
5290                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5291                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5292                    })
5293                }),
5294
5295                uid: wire.table.get(4).map(|envelope| {
5296                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5297                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5298                    })
5299                }),
5300
5301                gid: wire.table.get(5).map(|envelope| {
5302                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5303                        envelope.deref_unchecked::<::fidl_next::wire::Uint32>()
5304                    })
5305                }),
5306
5307                rdev: wire.table.get(6).map(|envelope| {
5308                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5309                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5310                    })
5311                }),
5312
5313                access_time: wire.table.get(7).map(|envelope| {
5314                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5315                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
5316                    })
5317                }),
5318
5319                casefold: wire.table.get(8).map(|envelope| {
5320                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5321                        envelope.deref_unchecked::<bool>()
5322                    })
5323                }),
5324
5325                selinux_context: wire.table.get(9).map(|envelope| {
5326                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5327                        envelope.deref_unchecked::<crate::wire::SelinuxContext<'de>>()
5328                    })
5329                }),
5330
5331                wrapping_key_id: wire.table.get(10).map(|envelope| {
5332                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5333                        envelope.deref_unchecked::<[u8; 16]>()
5334                    })
5335                }),
5336            }
5337        }
5338    }
5339
5340    ::fidl_next::bitflags::bitflags! {
5341        #[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 {
5342            #[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;
5343            #[doc = " The directory representation of a node.\n\n The connection will speak the [`Directory`] protocol.\n"]const DIRECTORY = 2;
5344            #[doc = " The file representation of a node.\n\n The connection will speak the [`File`] protocol.\n"]const FILE = 4;
5345            #[doc = " The symlink representation of a node.\n\n The connection will speak the [`Symlink`] protocol.\n"]const SYMLINK = 8;
5346            const _ = !0;
5347        }
5348    }
5349
5350    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E> for NodeProtocolKinds
5351    where
5352        ___E: ?Sized,
5353    {
5354        #[inline]
5355        fn encode(
5356            self,
5357            encoder: &mut ___E,
5358            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
5359            _: (),
5360        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5361            ::fidl_next::Encode::encode(&self, encoder, out, ())
5362        }
5363    }
5364
5365    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeProtocolKinds, ___E>
5366        for &'a NodeProtocolKinds
5367    where
5368        ___E: ?Sized,
5369    {
5370        #[inline]
5371        fn encode(
5372            self,
5373            _: &mut ___E,
5374            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeProtocolKinds>,
5375            _: (),
5376        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5377            ::fidl_next::munge!(let crate::wire::NodeProtocolKinds { value } = out);
5378
5379            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
5380            Ok(())
5381        }
5382    }
5383
5384    impl ::core::convert::From<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5385        fn from(wire: crate::wire::NodeProtocolKinds) -> Self {
5386            Self::from_bits_retain(u64::from(wire.value))
5387        }
5388    }
5389
5390    impl ::fidl_next::FromWire<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5391        #[inline]
5392        fn from_wire(wire: crate::wire::NodeProtocolKinds) -> Self {
5393            Self::from(wire)
5394        }
5395    }
5396
5397    impl ::fidl_next::FromWireRef<crate::wire::NodeProtocolKinds> for NodeProtocolKinds {
5398        #[inline]
5399        fn from_wire_ref(wire: &crate::wire::NodeProtocolKinds) -> Self {
5400            Self::from(*wire)
5401        }
5402    }
5403
5404    #[doc = " Denotes which hash algorithm is used to build the merkle tree for\n fsverity-enabled files.\n"]
5405    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5406    #[repr(u8)]
5407    pub enum HashAlgorithm {
5408        Sha256 = 1,
5409        Sha512 = 2,
5410        UnknownOrdinal_(u8) = 3,
5411    }
5412    impl ::std::convert::From<u8> for HashAlgorithm {
5413        fn from(value: u8) -> Self {
5414            match value {
5415                1 => Self::Sha256,
5416                2 => Self::Sha512,
5417
5418                _ => Self::UnknownOrdinal_(value),
5419            }
5420        }
5421    }
5422
5423    unsafe impl<___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for HashAlgorithm
5424    where
5425        ___E: ?Sized,
5426    {
5427        #[inline]
5428        fn encode(
5429            self,
5430            encoder: &mut ___E,
5431            out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
5432            _: (),
5433        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5434            ::fidl_next::Encode::encode(&self, encoder, out, ())
5435        }
5436    }
5437
5438    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::HashAlgorithm, ___E> for &'a HashAlgorithm
5439    where
5440        ___E: ?Sized,
5441    {
5442        #[inline]
5443        fn encode(
5444            self,
5445            encoder: &mut ___E,
5446            out: &mut ::core::mem::MaybeUninit<crate::wire::HashAlgorithm>,
5447            _: (),
5448        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5449            ::fidl_next::munge!(let crate::wire::HashAlgorithm { value } = out);
5450            let _ = value.write(u8::from(match *self {
5451                HashAlgorithm::Sha256 => 1,
5452
5453                HashAlgorithm::Sha512 => 2,
5454
5455                HashAlgorithm::UnknownOrdinal_(value) => value,
5456            }));
5457
5458            Ok(())
5459        }
5460    }
5461
5462    impl ::core::convert::From<crate::wire::HashAlgorithm> for HashAlgorithm {
5463        fn from(wire: crate::wire::HashAlgorithm) -> Self {
5464            match u8::from(wire.value) {
5465                1 => Self::Sha256,
5466
5467                2 => Self::Sha512,
5468
5469                value => Self::UnknownOrdinal_(value),
5470            }
5471        }
5472    }
5473
5474    impl ::fidl_next::FromWire<crate::wire::HashAlgorithm> for HashAlgorithm {
5475        #[inline]
5476        fn from_wire(wire: crate::wire::HashAlgorithm) -> Self {
5477            Self::from(wire)
5478        }
5479    }
5480
5481    impl ::fidl_next::FromWireRef<crate::wire::HashAlgorithm> for HashAlgorithm {
5482        #[inline]
5483        fn from_wire_ref(wire: &crate::wire::HashAlgorithm) -> Self {
5484            Self::from(*wire)
5485        }
5486    }
5487
5488    #[doc = " Set of options used to enable verity on a file.\n"]
5489    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5490    pub struct VerificationOptions {
5491        pub hash_algorithm: ::core::option::Option<crate::natural::HashAlgorithm>,
5492
5493        pub salt: ::core::option::Option<::std::vec::Vec<u8>>,
5494    }
5495
5496    impl VerificationOptions {
5497        fn __max_ordinal(&self) -> usize {
5498            if self.salt.is_some() {
5499                return 2;
5500            }
5501
5502            if self.hash_algorithm.is_some() {
5503                return 1;
5504            }
5505
5506            0
5507        }
5508    }
5509
5510    unsafe impl<___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
5511        for VerificationOptions
5512    where
5513        ___E: ::fidl_next::Encoder + ?Sized,
5514    {
5515        #[inline]
5516        fn encode(
5517            mut self,
5518            encoder: &mut ___E,
5519            out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
5520            _: (),
5521        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5522            ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
5523
5524            let max_ord = self.__max_ordinal();
5525
5526            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5527            ::fidl_next::Wire::zero_padding(&mut out);
5528
5529            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5530                ::fidl_next::wire::Envelope,
5531            >(encoder, max_ord);
5532
5533            for i in 1..=max_ord {
5534                match i {
5535                    2 => {
5536                        if let Some(value) = self.salt.take() {
5537                            ::fidl_next::wire::Envelope::encode_value::<
5538                                ::fidl_next::wire::Vector<'static, u8>,
5539                                ___E,
5540                            >(
5541                                value, preallocated.encoder, &mut out, (32, ())
5542                            )?;
5543                        } else {
5544                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5545                        }
5546                    }
5547
5548                    1 => {
5549                        if let Some(value) = self.hash_algorithm.take() {
5550                            ::fidl_next::wire::Envelope::encode_value::<
5551                                crate::wire::HashAlgorithm,
5552                                ___E,
5553                            >(
5554                                value, preallocated.encoder, &mut out, ()
5555                            )?;
5556                        } else {
5557                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5558                        }
5559                    }
5560
5561                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5562                }
5563                unsafe {
5564                    preallocated.write_next(out.assume_init_ref());
5565                }
5566            }
5567
5568            ::fidl_next::wire::Table::encode_len(table, max_ord);
5569
5570            Ok(())
5571        }
5572    }
5573
5574    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>
5575        for &'a VerificationOptions
5576    where
5577        ___E: ::fidl_next::Encoder + ?Sized,
5578    {
5579        #[inline]
5580        fn encode(
5581            self,
5582            encoder: &mut ___E,
5583            out: &mut ::core::mem::MaybeUninit<crate::wire::VerificationOptions<'static>>,
5584            _: (),
5585        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5586            ::fidl_next::munge!(let crate::wire::VerificationOptions { table } = out);
5587
5588            let max_ord = self.__max_ordinal();
5589
5590            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5591            ::fidl_next::Wire::zero_padding(&mut out);
5592
5593            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5594                ::fidl_next::wire::Envelope,
5595            >(encoder, max_ord);
5596
5597            for i in 1..=max_ord {
5598                match i {
5599                    2 => {
5600                        if let Some(value) = &self.salt {
5601                            ::fidl_next::wire::Envelope::encode_value::<
5602                                ::fidl_next::wire::Vector<'static, u8>,
5603                                ___E,
5604                            >(
5605                                value, preallocated.encoder, &mut out, (32, ())
5606                            )?;
5607                        } else {
5608                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5609                        }
5610                    }
5611
5612                    1 => {
5613                        if let Some(value) = &self.hash_algorithm {
5614                            ::fidl_next::wire::Envelope::encode_value::<
5615                                crate::wire::HashAlgorithm,
5616                                ___E,
5617                            >(
5618                                value, preallocated.encoder, &mut out, ()
5619                            )?;
5620                        } else {
5621                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5622                        }
5623                    }
5624
5625                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5626                }
5627                unsafe {
5628                    preallocated.write_next(out.assume_init_ref());
5629                }
5630            }
5631
5632            ::fidl_next::wire::Table::encode_len(table, max_ord);
5633
5634            Ok(())
5635        }
5636    }
5637
5638    impl<'de> ::fidl_next::FromWire<crate::wire::VerificationOptions<'de>> for VerificationOptions {
5639        #[inline]
5640        fn from_wire(wire_: crate::wire::VerificationOptions<'de>) -> Self {
5641            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
5642
5643            let hash_algorithm = wire_.table.get(1);
5644
5645            let salt = wire_.table.get(2);
5646
5647            Self {
5648                hash_algorithm: hash_algorithm.map(|envelope| {
5649                    ::fidl_next::FromWire::from_wire(unsafe {
5650                        envelope.read_unchecked::<crate::wire::HashAlgorithm>()
5651                    })
5652                }),
5653
5654                salt: salt.map(|envelope| {
5655                    ::fidl_next::FromWire::from_wire(unsafe {
5656                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5657                    })
5658                }),
5659            }
5660        }
5661    }
5662
5663    impl<'de> ::fidl_next::FromWireRef<crate::wire::VerificationOptions<'de>> for VerificationOptions {
5664        #[inline]
5665        fn from_wire_ref(wire: &crate::wire::VerificationOptions<'de>) -> Self {
5666            Self {
5667                hash_algorithm: wire.table.get(1).map(|envelope| {
5668                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5669                        envelope.deref_unchecked::<crate::wire::HashAlgorithm>()
5670                    })
5671                }),
5672
5673                salt: wire.table.get(2).map(|envelope| {
5674                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
5675                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
5676                    })
5677                }),
5678            }
5679        }
5680    }
5681
5682    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
5683    pub struct ImmutableNodeAttributes {
5684        pub protocols: ::core::option::Option<crate::natural::NodeProtocolKinds>,
5685
5686        pub abilities: ::core::option::Option<crate::natural::Operations>,
5687
5688        pub content_size: ::core::option::Option<u64>,
5689
5690        pub storage_size: ::core::option::Option<u64>,
5691
5692        pub link_count: ::core::option::Option<u64>,
5693
5694        pub id: ::core::option::Option<u64>,
5695
5696        pub change_time: ::core::option::Option<u64>,
5697
5698        pub options: ::core::option::Option<crate::natural::VerificationOptions>,
5699
5700        pub root_hash: ::core::option::Option<::std::vec::Vec<u8>>,
5701
5702        pub verity_enabled: ::core::option::Option<bool>,
5703    }
5704
5705    impl ImmutableNodeAttributes {
5706        fn __max_ordinal(&self) -> usize {
5707            if self.verity_enabled.is_some() {
5708                return 10;
5709            }
5710
5711            if self.root_hash.is_some() {
5712                return 9;
5713            }
5714
5715            if self.options.is_some() {
5716                return 8;
5717            }
5718
5719            if self.change_time.is_some() {
5720                return 7;
5721            }
5722
5723            if self.id.is_some() {
5724                return 6;
5725            }
5726
5727            if self.link_count.is_some() {
5728                return 5;
5729            }
5730
5731            if self.storage_size.is_some() {
5732                return 4;
5733            }
5734
5735            if self.content_size.is_some() {
5736                return 3;
5737            }
5738
5739            if self.abilities.is_some() {
5740                return 2;
5741            }
5742
5743            if self.protocols.is_some() {
5744                return 1;
5745            }
5746
5747            0
5748        }
5749    }
5750
5751    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
5752        for ImmutableNodeAttributes
5753    where
5754        ___E: ::fidl_next::Encoder + ?Sized,
5755    {
5756        #[inline]
5757        fn encode(
5758            mut self,
5759            encoder: &mut ___E,
5760            out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
5761            _: (),
5762        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5763            ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
5764
5765            let max_ord = self.__max_ordinal();
5766
5767            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5768            ::fidl_next::Wire::zero_padding(&mut out);
5769
5770            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5771                ::fidl_next::wire::Envelope,
5772            >(encoder, max_ord);
5773
5774            for i in 1..=max_ord {
5775                match i {
5776                    10 => {
5777                        if let Some(value) = self.verity_enabled.take() {
5778                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5779                                value,
5780                                preallocated.encoder,
5781                                &mut out,
5782                                (),
5783                            )?;
5784                        } else {
5785                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5786                        }
5787                    }
5788
5789                    9 => {
5790                        if let Some(value) = self.root_hash.take() {
5791                            ::fidl_next::wire::Envelope::encode_value::<
5792                                ::fidl_next::wire::Vector<'static, u8>,
5793                                ___E,
5794                            >(
5795                                value, preallocated.encoder, &mut out, (64, ())
5796                            )?;
5797                        } else {
5798                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5799                        }
5800                    }
5801
5802                    8 => {
5803                        if let Some(value) = self.options.take() {
5804                            ::fidl_next::wire::Envelope::encode_value::<
5805                                crate::wire::VerificationOptions<'static>,
5806                                ___E,
5807                            >(
5808                                value, preallocated.encoder, &mut out, ()
5809                            )?;
5810                        } else {
5811                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5812                        }
5813                    }
5814
5815                    7 => {
5816                        if let Some(value) = self.change_time.take() {
5817                            ::fidl_next::wire::Envelope::encode_value::<
5818                                ::fidl_next::wire::Uint64,
5819                                ___E,
5820                            >(
5821                                value, preallocated.encoder, &mut out, ()
5822                            )?;
5823                        } else {
5824                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5825                        }
5826                    }
5827
5828                    6 => {
5829                        if let Some(value) = self.id.take() {
5830                            ::fidl_next::wire::Envelope::encode_value::<
5831                                ::fidl_next::wire::Uint64,
5832                                ___E,
5833                            >(
5834                                value, preallocated.encoder, &mut out, ()
5835                            )?;
5836                        } else {
5837                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5838                        }
5839                    }
5840
5841                    5 => {
5842                        if let Some(value) = self.link_count.take() {
5843                            ::fidl_next::wire::Envelope::encode_value::<
5844                                ::fidl_next::wire::Uint64,
5845                                ___E,
5846                            >(
5847                                value, preallocated.encoder, &mut out, ()
5848                            )?;
5849                        } else {
5850                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5851                        }
5852                    }
5853
5854                    4 => {
5855                        if let Some(value) = self.storage_size.take() {
5856                            ::fidl_next::wire::Envelope::encode_value::<
5857                                ::fidl_next::wire::Uint64,
5858                                ___E,
5859                            >(
5860                                value, preallocated.encoder, &mut out, ()
5861                            )?;
5862                        } else {
5863                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5864                        }
5865                    }
5866
5867                    3 => {
5868                        if let Some(value) = self.content_size.take() {
5869                            ::fidl_next::wire::Envelope::encode_value::<
5870                                ::fidl_next::wire::Uint64,
5871                                ___E,
5872                            >(
5873                                value, preallocated.encoder, &mut out, ()
5874                            )?;
5875                        } else {
5876                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5877                        }
5878                    }
5879
5880                    2 => {
5881                        if let Some(value) = self.abilities.take() {
5882                            ::fidl_next::wire::Envelope::encode_value::<
5883                                crate::wire::Operations,
5884                                ___E,
5885                            >(
5886                                value, preallocated.encoder, &mut out, ()
5887                            )?;
5888                        } else {
5889                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5890                        }
5891                    }
5892
5893                    1 => {
5894                        if let Some(value) = self.protocols.take() {
5895                            ::fidl_next::wire::Envelope::encode_value::<
5896                                crate::wire::NodeProtocolKinds,
5897                                ___E,
5898                            >(
5899                                value, preallocated.encoder, &mut out, ()
5900                            )?;
5901                        } else {
5902                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5903                        }
5904                    }
5905
5906                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
5907                }
5908                unsafe {
5909                    preallocated.write_next(out.assume_init_ref());
5910                }
5911            }
5912
5913            ::fidl_next::wire::Table::encode_len(table, max_ord);
5914
5915            Ok(())
5916        }
5917    }
5918
5919    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>
5920        for &'a ImmutableNodeAttributes
5921    where
5922        ___E: ::fidl_next::Encoder + ?Sized,
5923    {
5924        #[inline]
5925        fn encode(
5926            self,
5927            encoder: &mut ___E,
5928            out: &mut ::core::mem::MaybeUninit<crate::wire::ImmutableNodeAttributes<'static>>,
5929            _: (),
5930        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5931            ::fidl_next::munge!(let crate::wire::ImmutableNodeAttributes { table } = out);
5932
5933            let max_ord = self.__max_ordinal();
5934
5935            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
5936            ::fidl_next::Wire::zero_padding(&mut out);
5937
5938            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
5939                ::fidl_next::wire::Envelope,
5940            >(encoder, max_ord);
5941
5942            for i in 1..=max_ord {
5943                match i {
5944                    10 => {
5945                        if let Some(value) = &self.verity_enabled {
5946                            ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
5947                                value,
5948                                preallocated.encoder,
5949                                &mut out,
5950                                (),
5951                            )?;
5952                        } else {
5953                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5954                        }
5955                    }
5956
5957                    9 => {
5958                        if let Some(value) = &self.root_hash {
5959                            ::fidl_next::wire::Envelope::encode_value::<
5960                                ::fidl_next::wire::Vector<'static, u8>,
5961                                ___E,
5962                            >(
5963                                value, preallocated.encoder, &mut out, (64, ())
5964                            )?;
5965                        } else {
5966                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5967                        }
5968                    }
5969
5970                    8 => {
5971                        if let Some(value) = &self.options {
5972                            ::fidl_next::wire::Envelope::encode_value::<
5973                                crate::wire::VerificationOptions<'static>,
5974                                ___E,
5975                            >(
5976                                value, preallocated.encoder, &mut out, ()
5977                            )?;
5978                        } else {
5979                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5980                        }
5981                    }
5982
5983                    7 => {
5984                        if let Some(value) = &self.change_time {
5985                            ::fidl_next::wire::Envelope::encode_value::<
5986                                ::fidl_next::wire::Uint64,
5987                                ___E,
5988                            >(
5989                                value, preallocated.encoder, &mut out, ()
5990                            )?;
5991                        } else {
5992                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
5993                        }
5994                    }
5995
5996                    6 => {
5997                        if let Some(value) = &self.id {
5998                            ::fidl_next::wire::Envelope::encode_value::<
5999                                ::fidl_next::wire::Uint64,
6000                                ___E,
6001                            >(
6002                                value, preallocated.encoder, &mut out, ()
6003                            )?;
6004                        } else {
6005                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6006                        }
6007                    }
6008
6009                    5 => {
6010                        if let Some(value) = &self.link_count {
6011                            ::fidl_next::wire::Envelope::encode_value::<
6012                                ::fidl_next::wire::Uint64,
6013                                ___E,
6014                            >(
6015                                value, preallocated.encoder, &mut out, ()
6016                            )?;
6017                        } else {
6018                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6019                        }
6020                    }
6021
6022                    4 => {
6023                        if let Some(value) = &self.storage_size {
6024                            ::fidl_next::wire::Envelope::encode_value::<
6025                                ::fidl_next::wire::Uint64,
6026                                ___E,
6027                            >(
6028                                value, preallocated.encoder, &mut out, ()
6029                            )?;
6030                        } else {
6031                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6032                        }
6033                    }
6034
6035                    3 => {
6036                        if let Some(value) = &self.content_size {
6037                            ::fidl_next::wire::Envelope::encode_value::<
6038                                ::fidl_next::wire::Uint64,
6039                                ___E,
6040                            >(
6041                                value, preallocated.encoder, &mut out, ()
6042                            )?;
6043                        } else {
6044                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6045                        }
6046                    }
6047
6048                    2 => {
6049                        if let Some(value) = &self.abilities {
6050                            ::fidl_next::wire::Envelope::encode_value::<
6051                                crate::wire::Operations,
6052                                ___E,
6053                            >(
6054                                value, preallocated.encoder, &mut out, ()
6055                            )?;
6056                        } else {
6057                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6058                        }
6059                    }
6060
6061                    1 => {
6062                        if let Some(value) = &self.protocols {
6063                            ::fidl_next::wire::Envelope::encode_value::<
6064                                crate::wire::NodeProtocolKinds,
6065                                ___E,
6066                            >(
6067                                value, preallocated.encoder, &mut out, ()
6068                            )?;
6069                        } else {
6070                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6071                        }
6072                    }
6073
6074                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6075                }
6076                unsafe {
6077                    preallocated.write_next(out.assume_init_ref());
6078                }
6079            }
6080
6081            ::fidl_next::wire::Table::encode_len(table, max_ord);
6082
6083            Ok(())
6084        }
6085    }
6086
6087    impl<'de> ::fidl_next::FromWire<crate::wire::ImmutableNodeAttributes<'de>>
6088        for ImmutableNodeAttributes
6089    {
6090        #[inline]
6091        fn from_wire(wire_: crate::wire::ImmutableNodeAttributes<'de>) -> Self {
6092            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6093
6094            let protocols = wire_.table.get(1);
6095
6096            let abilities = wire_.table.get(2);
6097
6098            let content_size = wire_.table.get(3);
6099
6100            let storage_size = wire_.table.get(4);
6101
6102            let link_count = wire_.table.get(5);
6103
6104            let id = wire_.table.get(6);
6105
6106            let change_time = wire_.table.get(7);
6107
6108            let options = wire_.table.get(8);
6109
6110            let root_hash = wire_.table.get(9);
6111
6112            let verity_enabled = wire_.table.get(10);
6113
6114            Self {
6115                protocols: protocols.map(|envelope| {
6116                    ::fidl_next::FromWire::from_wire(unsafe {
6117                        envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
6118                    })
6119                }),
6120
6121                abilities: abilities.map(|envelope| {
6122                    ::fidl_next::FromWire::from_wire(unsafe {
6123                        envelope.read_unchecked::<crate::wire::Operations>()
6124                    })
6125                }),
6126
6127                content_size: content_size.map(|envelope| {
6128                    ::fidl_next::FromWire::from_wire(unsafe {
6129                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6130                    })
6131                }),
6132
6133                storage_size: storage_size.map(|envelope| {
6134                    ::fidl_next::FromWire::from_wire(unsafe {
6135                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6136                    })
6137                }),
6138
6139                link_count: link_count.map(|envelope| {
6140                    ::fidl_next::FromWire::from_wire(unsafe {
6141                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6142                    })
6143                }),
6144
6145                id: id.map(|envelope| {
6146                    ::fidl_next::FromWire::from_wire(unsafe {
6147                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6148                    })
6149                }),
6150
6151                change_time: change_time.map(|envelope| {
6152                    ::fidl_next::FromWire::from_wire(unsafe {
6153                        envelope.read_unchecked::<::fidl_next::wire::Uint64>()
6154                    })
6155                }),
6156
6157                options: options.map(|envelope| {
6158                    ::fidl_next::FromWire::from_wire(unsafe {
6159                        envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
6160                    })
6161                }),
6162
6163                root_hash: root_hash.map(|envelope| {
6164                    ::fidl_next::FromWire::from_wire(unsafe {
6165                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6166                    })
6167                }),
6168
6169                verity_enabled: verity_enabled.map(|envelope| {
6170                    ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
6171                }),
6172            }
6173        }
6174    }
6175
6176    impl<'de> ::fidl_next::FromWireRef<crate::wire::ImmutableNodeAttributes<'de>>
6177        for ImmutableNodeAttributes
6178    {
6179        #[inline]
6180        fn from_wire_ref(wire: &crate::wire::ImmutableNodeAttributes<'de>) -> Self {
6181            Self {
6182                protocols: wire.table.get(1).map(|envelope| {
6183                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6184                        envelope.deref_unchecked::<crate::wire::NodeProtocolKinds>()
6185                    })
6186                }),
6187
6188                abilities: wire.table.get(2).map(|envelope| {
6189                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6190                        envelope.deref_unchecked::<crate::wire::Operations>()
6191                    })
6192                }),
6193
6194                content_size: wire.table.get(3).map(|envelope| {
6195                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6196                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6197                    })
6198                }),
6199
6200                storage_size: wire.table.get(4).map(|envelope| {
6201                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6202                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6203                    })
6204                }),
6205
6206                link_count: wire.table.get(5).map(|envelope| {
6207                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6208                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6209                    })
6210                }),
6211
6212                id: wire.table.get(6).map(|envelope| {
6213                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6214                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6215                    })
6216                }),
6217
6218                change_time: wire.table.get(7).map(|envelope| {
6219                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6220                        envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
6221                    })
6222                }),
6223
6224                options: wire.table.get(8).map(|envelope| {
6225                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6226                        envelope.deref_unchecked::<crate::wire::VerificationOptions<'de>>()
6227                    })
6228                }),
6229
6230                root_hash: wire.table.get(9).map(|envelope| {
6231                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6232                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6233                    })
6234                }),
6235
6236                verity_enabled: wire.table.get(10).map(|envelope| {
6237                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6238                        envelope.deref_unchecked::<bool>()
6239                    })
6240                }),
6241            }
6242        }
6243    }
6244
6245    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6246    pub struct NodeAttributes2 {
6247        pub mutable_attributes: crate::natural::MutableNodeAttributes,
6248
6249        pub immutable_attributes: crate::natural::ImmutableNodeAttributes,
6250    }
6251
6252    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
6253        for NodeAttributes2
6254    where
6255        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6256        ___E: ::fidl_next::Encoder,
6257    {
6258        #[inline]
6259        fn encode(
6260            self,
6261            encoder_: &mut ___E,
6262            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
6263            _: (),
6264        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6265            ::fidl_next::munge! {
6266                let crate::wire::NodeAttributes2 {
6267                    mutable_attributes,
6268                    immutable_attributes,
6269
6270                } = out_;
6271            }
6272
6273            ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
6274
6275            let mut _field =
6276                unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
6277
6278            ::fidl_next::Encode::encode(
6279                self.immutable_attributes,
6280                encoder_,
6281                immutable_attributes,
6282                (),
6283            )?;
6284
6285            let mut _field =
6286                unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
6287
6288            Ok(())
6289        }
6290    }
6291
6292    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
6293        for &'a NodeAttributes2
6294    where
6295        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6296        ___E: ::fidl_next::Encoder,
6297    {
6298        #[inline]
6299        fn encode(
6300            self,
6301            encoder_: &mut ___E,
6302            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
6303            _: (),
6304        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6305            ::fidl_next::munge! {
6306                let crate::wire::NodeAttributes2 {
6307                    mutable_attributes,
6308                    immutable_attributes,
6309
6310                } = out_;
6311            }
6312
6313            ::fidl_next::Encode::encode(
6314                &self.mutable_attributes,
6315                encoder_,
6316                mutable_attributes,
6317                (),
6318            )?;
6319
6320            let mut _field =
6321                unsafe { ::fidl_next::Slot::new_unchecked(mutable_attributes.as_mut_ptr()) };
6322
6323            ::fidl_next::Encode::encode(
6324                &self.immutable_attributes,
6325                encoder_,
6326                immutable_attributes,
6327                (),
6328            )?;
6329
6330            let mut _field =
6331                unsafe { ::fidl_next::Slot::new_unchecked(immutable_attributes.as_mut_ptr()) };
6332
6333            Ok(())
6334        }
6335    }
6336
6337    unsafe impl<___E>
6338        ::fidl_next::EncodeOption<
6339            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6340            ___E,
6341        > for NodeAttributes2
6342    where
6343        ___E: ::fidl_next::Encoder + ?Sized,
6344        NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
6345    {
6346        #[inline]
6347        fn encode_option(
6348            this: ::core::option::Option<Self>,
6349            encoder: &mut ___E,
6350            out: &mut ::core::mem::MaybeUninit<
6351                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6352            >,
6353            _: (),
6354        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6355            if let Some(inner) = this {
6356                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6357                ::fidl_next::wire::Box::encode_present(out);
6358            } else {
6359                ::fidl_next::wire::Box::encode_absent(out);
6360            }
6361
6362            Ok(())
6363        }
6364    }
6365
6366    unsafe impl<'a, ___E>
6367        ::fidl_next::EncodeOption<
6368            ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6369            ___E,
6370        > for &'a NodeAttributes2
6371    where
6372        ___E: ::fidl_next::Encoder + ?Sized,
6373        &'a NodeAttributes2: ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>,
6374    {
6375        #[inline]
6376        fn encode_option(
6377            this: ::core::option::Option<Self>,
6378            encoder: &mut ___E,
6379            out: &mut ::core::mem::MaybeUninit<
6380                ::fidl_next::wire::Box<'static, crate::wire::NodeAttributes2<'static>>,
6381            >,
6382            _: (),
6383        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6384            if let Some(inner) = this {
6385                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
6386                ::fidl_next::wire::Box::encode_present(out);
6387            } else {
6388                ::fidl_next::wire::Box::encode_absent(out);
6389            }
6390
6391            Ok(())
6392        }
6393    }
6394
6395    impl<'de> ::fidl_next::FromWire<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
6396        #[inline]
6397        fn from_wire(wire: crate::wire::NodeAttributes2<'de>) -> Self {
6398            Self {
6399                mutable_attributes: ::fidl_next::FromWire::from_wire(wire.mutable_attributes),
6400
6401                immutable_attributes: ::fidl_next::FromWire::from_wire(wire.immutable_attributes),
6402            }
6403        }
6404    }
6405
6406    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeAttributes2<'de>> for NodeAttributes2 {
6407        #[inline]
6408        fn from_wire_ref(wire: &crate::wire::NodeAttributes2<'de>) -> Self {
6409            Self {
6410                mutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
6411                    &wire.mutable_attributes,
6412                ),
6413
6414                immutable_attributes: ::fidl_next::FromWireRef::from_wire_ref(
6415                    &wire.immutable_attributes,
6416                ),
6417            }
6418        }
6419    }
6420
6421    #[doc = " Information that describes the target node.\n"]
6422    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6423    pub struct NodeInfo {
6424        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6425    }
6426
6427    impl NodeInfo {
6428        fn __max_ordinal(&self) -> usize {
6429            if self.attributes.is_some() {
6430                return 1;
6431            }
6432
6433            0
6434        }
6435    }
6436
6437    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for NodeInfo
6438    where
6439        ___E: ::fidl_next::Encoder + ?Sized,
6440    {
6441        #[inline]
6442        fn encode(
6443            mut self,
6444            encoder: &mut ___E,
6445            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
6446            _: (),
6447        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6448            ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
6449
6450            let max_ord = self.__max_ordinal();
6451
6452            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6453            ::fidl_next::Wire::zero_padding(&mut out);
6454
6455            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6456                ::fidl_next::wire::Envelope,
6457            >(encoder, max_ord);
6458
6459            for i in 1..=max_ord {
6460                match i {
6461                    1 => {
6462                        if let Some(value) = self.attributes.take() {
6463                            ::fidl_next::wire::Envelope::encode_value::<
6464                                crate::wire::NodeAttributes2<'static>,
6465                                ___E,
6466                            >(
6467                                value, preallocated.encoder, &mut out, ()
6468                            )?;
6469                        } else {
6470                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6471                        }
6472                    }
6473
6474                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6475                }
6476                unsafe {
6477                    preallocated.write_next(out.assume_init_ref());
6478                }
6479            }
6480
6481            ::fidl_next::wire::Table::encode_len(table, max_ord);
6482
6483            Ok(())
6484        }
6485    }
6486
6487    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeInfo<'static>, ___E> for &'a NodeInfo
6488    where
6489        ___E: ::fidl_next::Encoder + ?Sized,
6490    {
6491        #[inline]
6492        fn encode(
6493            self,
6494            encoder: &mut ___E,
6495            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfo<'static>>,
6496            _: (),
6497        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6498            ::fidl_next::munge!(let crate::wire::NodeInfo { table } = out);
6499
6500            let max_ord = self.__max_ordinal();
6501
6502            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6503            ::fidl_next::Wire::zero_padding(&mut out);
6504
6505            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6506                ::fidl_next::wire::Envelope,
6507            >(encoder, max_ord);
6508
6509            for i in 1..=max_ord {
6510                match i {
6511                    1 => {
6512                        if let Some(value) = &self.attributes {
6513                            ::fidl_next::wire::Envelope::encode_value::<
6514                                crate::wire::NodeAttributes2<'static>,
6515                                ___E,
6516                            >(
6517                                value, preallocated.encoder, &mut out, ()
6518                            )?;
6519                        } else {
6520                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6521                        }
6522                    }
6523
6524                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6525                }
6526                unsafe {
6527                    preallocated.write_next(out.assume_init_ref());
6528                }
6529            }
6530
6531            ::fidl_next::wire::Table::encode_len(table, max_ord);
6532
6533            Ok(())
6534        }
6535    }
6536
6537    impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfo<'de>> for NodeInfo {
6538        #[inline]
6539        fn from_wire(wire_: crate::wire::NodeInfo<'de>) -> Self {
6540            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6541
6542            let attributes = wire_.table.get(1);
6543
6544            Self {
6545                attributes: attributes.map(|envelope| {
6546                    ::fidl_next::FromWire::from_wire(unsafe {
6547                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6548                    })
6549                }),
6550            }
6551        }
6552    }
6553
6554    impl<'de> ::fidl_next::FromWireRef<crate::wire::NodeInfo<'de>> for NodeInfo {
6555        #[inline]
6556        fn from_wire_ref(wire: &crate::wire::NodeInfo<'de>) -> Self {
6557            Self {
6558                attributes: wire.table.get(1).map(|envelope| {
6559                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6560                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6561                    })
6562                }),
6563            }
6564        }
6565    }
6566
6567    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6568    pub struct DirectoryInfo {
6569        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6570    }
6571
6572    impl DirectoryInfo {
6573        fn __max_ordinal(&self) -> usize {
6574            if self.attributes.is_some() {
6575                return 1;
6576            }
6577
6578            0
6579        }
6580    }
6581
6582    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E> for DirectoryInfo
6583    where
6584        ___E: ::fidl_next::Encoder + ?Sized,
6585    {
6586        #[inline]
6587        fn encode(
6588            mut self,
6589            encoder: &mut ___E,
6590            out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
6591            _: (),
6592        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6593            ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
6594
6595            let max_ord = self.__max_ordinal();
6596
6597            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6598            ::fidl_next::Wire::zero_padding(&mut out);
6599
6600            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6601                ::fidl_next::wire::Envelope,
6602            >(encoder, max_ord);
6603
6604            for i in 1..=max_ord {
6605                match i {
6606                    1 => {
6607                        if let Some(value) = self.attributes.take() {
6608                            ::fidl_next::wire::Envelope::encode_value::<
6609                                crate::wire::NodeAttributes2<'static>,
6610                                ___E,
6611                            >(
6612                                value, preallocated.encoder, &mut out, ()
6613                            )?;
6614                        } else {
6615                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6616                        }
6617                    }
6618
6619                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6620                }
6621                unsafe {
6622                    preallocated.write_next(out.assume_init_ref());
6623                }
6624            }
6625
6626            ::fidl_next::wire::Table::encode_len(table, max_ord);
6627
6628            Ok(())
6629        }
6630    }
6631
6632    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirectoryInfo<'static>, ___E>
6633        for &'a DirectoryInfo
6634    where
6635        ___E: ::fidl_next::Encoder + ?Sized,
6636    {
6637        #[inline]
6638        fn encode(
6639            self,
6640            encoder: &mut ___E,
6641            out: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryInfo<'static>>,
6642            _: (),
6643        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6644            ::fidl_next::munge!(let crate::wire::DirectoryInfo { table } = out);
6645
6646            let max_ord = self.__max_ordinal();
6647
6648            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6649            ::fidl_next::Wire::zero_padding(&mut out);
6650
6651            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6652                ::fidl_next::wire::Envelope,
6653            >(encoder, max_ord);
6654
6655            for i in 1..=max_ord {
6656                match i {
6657                    1 => {
6658                        if let Some(value) = &self.attributes {
6659                            ::fidl_next::wire::Envelope::encode_value::<
6660                                crate::wire::NodeAttributes2<'static>,
6661                                ___E,
6662                            >(
6663                                value, preallocated.encoder, &mut out, ()
6664                            )?;
6665                        } else {
6666                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6667                        }
6668                    }
6669
6670                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6671                }
6672                unsafe {
6673                    preallocated.write_next(out.assume_init_ref());
6674                }
6675            }
6676
6677            ::fidl_next::wire::Table::encode_len(table, max_ord);
6678
6679            Ok(())
6680        }
6681    }
6682
6683    impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
6684        #[inline]
6685        fn from_wire(wire_: crate::wire::DirectoryInfo<'de>) -> Self {
6686            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6687
6688            let attributes = wire_.table.get(1);
6689
6690            Self {
6691                attributes: attributes.map(|envelope| {
6692                    ::fidl_next::FromWire::from_wire(unsafe {
6693                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6694                    })
6695                }),
6696            }
6697        }
6698    }
6699
6700    impl<'de> ::fidl_next::FromWireRef<crate::wire::DirectoryInfo<'de>> for DirectoryInfo {
6701        #[inline]
6702        fn from_wire_ref(wire: &crate::wire::DirectoryInfo<'de>) -> Self {
6703            Self {
6704                attributes: wire.table.get(1).map(|envelope| {
6705                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6706                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6707                    })
6708                }),
6709            }
6710        }
6711    }
6712
6713    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6714    pub struct SymlinkInfo {
6715        pub target: ::core::option::Option<::std::vec::Vec<u8>>,
6716
6717        pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
6718    }
6719
6720    impl SymlinkInfo {
6721        fn __max_ordinal(&self) -> usize {
6722            if self.attributes.is_some() {
6723                return 2;
6724            }
6725
6726            if self.target.is_some() {
6727                return 1;
6728            }
6729
6730            0
6731        }
6732    }
6733
6734    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E> for SymlinkInfo
6735    where
6736        ___E: ::fidl_next::Encoder + ?Sized,
6737    {
6738        #[inline]
6739        fn encode(
6740            mut self,
6741            encoder: &mut ___E,
6742            out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
6743            _: (),
6744        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6745            ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
6746
6747            let max_ord = self.__max_ordinal();
6748
6749            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6750            ::fidl_next::Wire::zero_padding(&mut out);
6751
6752            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6753                ::fidl_next::wire::Envelope,
6754            >(encoder, max_ord);
6755
6756            for i in 1..=max_ord {
6757                match i {
6758                    2 => {
6759                        if let Some(value) = self.attributes.take() {
6760                            ::fidl_next::wire::Envelope::encode_value::<
6761                                crate::wire::NodeAttributes2<'static>,
6762                                ___E,
6763                            >(
6764                                value, preallocated.encoder, &mut out, ()
6765                            )?;
6766                        } else {
6767                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6768                        }
6769                    }
6770
6771                    1 => {
6772                        if let Some(value) = self.target.take() {
6773                            ::fidl_next::wire::Envelope::encode_value::<
6774                                ::fidl_next::wire::Vector<'static, u8>,
6775                                ___E,
6776                            >(
6777                                value, preallocated.encoder, &mut out, (4095, ())
6778                            )?;
6779                        } else {
6780                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6781                        }
6782                    }
6783
6784                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6785                }
6786                unsafe {
6787                    preallocated.write_next(out.assume_init_ref());
6788                }
6789            }
6790
6791            ::fidl_next::wire::Table::encode_len(table, max_ord);
6792
6793            Ok(())
6794        }
6795    }
6796
6797    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkInfo<'static>, ___E>
6798        for &'a SymlinkInfo
6799    where
6800        ___E: ::fidl_next::Encoder + ?Sized,
6801    {
6802        #[inline]
6803        fn encode(
6804            self,
6805            encoder: &mut ___E,
6806            out: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkInfo<'static>>,
6807            _: (),
6808        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6809            ::fidl_next::munge!(let crate::wire::SymlinkInfo { table } = out);
6810
6811            let max_ord = self.__max_ordinal();
6812
6813            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
6814            ::fidl_next::Wire::zero_padding(&mut out);
6815
6816            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
6817                ::fidl_next::wire::Envelope,
6818            >(encoder, max_ord);
6819
6820            for i in 1..=max_ord {
6821                match i {
6822                    2 => {
6823                        if let Some(value) = &self.attributes {
6824                            ::fidl_next::wire::Envelope::encode_value::<
6825                                crate::wire::NodeAttributes2<'static>,
6826                                ___E,
6827                            >(
6828                                value, preallocated.encoder, &mut out, ()
6829                            )?;
6830                        } else {
6831                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6832                        }
6833                    }
6834
6835                    1 => {
6836                        if let Some(value) = &self.target {
6837                            ::fidl_next::wire::Envelope::encode_value::<
6838                                ::fidl_next::wire::Vector<'static, u8>,
6839                                ___E,
6840                            >(
6841                                value, preallocated.encoder, &mut out, (4095, ())
6842                            )?;
6843                        } else {
6844                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
6845                        }
6846                    }
6847
6848                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
6849                }
6850                unsafe {
6851                    preallocated.write_next(out.assume_init_ref());
6852                }
6853            }
6854
6855            ::fidl_next::wire::Table::encode_len(table, max_ord);
6856
6857            Ok(())
6858        }
6859    }
6860
6861    impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
6862        #[inline]
6863        fn from_wire(wire_: crate::wire::SymlinkInfo<'de>) -> Self {
6864            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
6865
6866            let target = wire_.table.get(1);
6867
6868            let attributes = wire_.table.get(2);
6869
6870            Self {
6871                target: target.map(|envelope| {
6872                    ::fidl_next::FromWire::from_wire(unsafe {
6873                        envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6874                    })
6875                }),
6876
6877                attributes: attributes.map(|envelope| {
6878                    ::fidl_next::FromWire::from_wire(unsafe {
6879                        envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
6880                    })
6881                }),
6882            }
6883        }
6884    }
6885
6886    impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkInfo<'de>> for SymlinkInfo {
6887        #[inline]
6888        fn from_wire_ref(wire: &crate::wire::SymlinkInfo<'de>) -> Self {
6889            Self {
6890                target: wire.table.get(1).map(|envelope| {
6891                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6892                        envelope.deref_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
6893                    })
6894                }),
6895
6896                attributes: wire.table.get(2).map(|envelope| {
6897                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
6898                        envelope.deref_unchecked::<crate::wire::NodeAttributes2<'de>>()
6899                    })
6900                }),
6901            }
6902        }
6903    }
6904
6905    ::fidl_next::bitflags::bitflags! {
6906        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct NodeAttributesQuery: u64 {
6907            #[doc = " Requests [`NodeAttributes.protocols`].\n"]const PROTOCOLS = 1;
6908            #[doc = " Requests [`NodeAttributes.abilities`].\n"]const ABILITIES = 2;
6909            #[doc = " Requests [`NodeAttributes.content_size`].\n"]const CONTENT_SIZE = 4;
6910            #[doc = " Requests [`NodeAttributes.storage_size`].\n"]const STORAGE_SIZE = 8;
6911            #[doc = " Requests [`NodeAttributes.link_count`].\n"]const LINK_COUNT = 16;
6912            #[doc = " Requests [`NodeAttributes.id`].\n"]const ID = 32;
6913            #[doc = " Requests [`NodeAttributes.creation_time`].\n"]const CREATION_TIME = 64;
6914            #[doc = " Requests [`NodeAttributes.modification_time`].\n"]const MODIFICATION_TIME = 128;
6915            #[doc = " Posix attributes.\n"]const MODE = 256;
6916            const UID = 512;
6917            const GID = 1024;
6918            const RDEV = 2048;
6919            const ACCESS_TIME = 4096;
6920            const CHANGE_TIME = 8192;
6921            #[doc = " Verity attributes.\n"]const OPTIONS = 16384;
6922            const ROOT_HASH = 32768;
6923            const VERITY_ENABLED = 65536;
6924            #[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;
6925            #[doc = " Requests [`MutableNodeAttributes.selinux_context`]. See that field for more detail.\n"]const SELINUX_CONTEXT = 262144;
6926            #[doc = " fscrypt attribute.\n"]const WRAPPING_KEY_ID = 524288;
6927            #[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;
6928            const _ = !0;
6929        }
6930    }
6931
6932    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
6933        for NodeAttributesQuery
6934    where
6935        ___E: ?Sized,
6936    {
6937        #[inline]
6938        fn encode(
6939            self,
6940            encoder: &mut ___E,
6941            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
6942            _: (),
6943        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6944            ::fidl_next::Encode::encode(&self, encoder, out, ())
6945        }
6946    }
6947
6948    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>
6949        for &'a NodeAttributesQuery
6950    where
6951        ___E: ?Sized,
6952    {
6953        #[inline]
6954        fn encode(
6955            self,
6956            _: &mut ___E,
6957            out: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributesQuery>,
6958            _: (),
6959        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6960            ::fidl_next::munge!(let crate::wire::NodeAttributesQuery { value } = out);
6961
6962            let _ = value.write(::fidl_next::wire::Uint64::from(self.bits()));
6963            Ok(())
6964        }
6965    }
6966
6967    impl ::core::convert::From<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6968        fn from(wire: crate::wire::NodeAttributesQuery) -> Self {
6969            Self::from_bits_retain(u64::from(wire.value))
6970        }
6971    }
6972
6973    impl ::fidl_next::FromWire<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6974        #[inline]
6975        fn from_wire(wire: crate::wire::NodeAttributesQuery) -> Self {
6976            Self::from(wire)
6977        }
6978    }
6979
6980    impl ::fidl_next::FromWireRef<crate::wire::NodeAttributesQuery> for NodeAttributesQuery {
6981        #[inline]
6982        fn from_wire_ref(wire: &crate::wire::NodeAttributesQuery) -> Self {
6983            Self::from(*wire)
6984        }
6985    }
6986
6987    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
6988    #[repr(C)]
6989    pub struct NodeGetAttributesRequest {
6990        pub query: crate::natural::NodeAttributesQuery,
6991    }
6992
6993    unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
6994        for NodeGetAttributesRequest
6995    where
6996        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6997    {
6998        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
6999            Self,
7000            crate::wire::NodeGetAttributesRequest,
7001        > = unsafe {
7002            ::fidl_next::CopyOptimization::enable_if(
7003                true && <crate::natural::NodeAttributesQuery as ::fidl_next::Encode<
7004                    crate::wire::NodeAttributesQuery,
7005                    ___E,
7006                >>::COPY_OPTIMIZATION
7007                    .is_enabled(),
7008            )
7009        };
7010
7011        #[inline]
7012        fn encode(
7013            self,
7014            encoder_: &mut ___E,
7015            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
7016            _: (),
7017        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7018            ::fidl_next::munge! {
7019                let crate::wire::NodeGetAttributesRequest {
7020                    query,
7021
7022                } = out_;
7023            }
7024
7025            ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
7026
7027            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
7028
7029            Ok(())
7030        }
7031    }
7032
7033    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
7034        for &'a NodeGetAttributesRequest
7035    where
7036        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7037    {
7038        #[inline]
7039        fn encode(
7040            self,
7041            encoder_: &mut ___E,
7042            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
7043            _: (),
7044        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7045            ::fidl_next::munge! {
7046                let crate::wire::NodeGetAttributesRequest {
7047                    query,
7048
7049                } = out_;
7050            }
7051
7052            ::fidl_next::Encode::encode(&self.query, encoder_, query, ())?;
7053
7054            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(query.as_mut_ptr()) };
7055
7056            Ok(())
7057        }
7058    }
7059
7060    unsafe impl<___E>
7061        ::fidl_next::EncodeOption<
7062            ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7063            ___E,
7064        > for NodeGetAttributesRequest
7065    where
7066        ___E: ::fidl_next::Encoder + ?Sized,
7067        NodeGetAttributesRequest: ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
7068    {
7069        #[inline]
7070        fn encode_option(
7071            this: ::core::option::Option<Self>,
7072            encoder: &mut ___E,
7073            out: &mut ::core::mem::MaybeUninit<
7074                ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7075            >,
7076            _: (),
7077        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7078            if let Some(inner) = this {
7079                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7080                ::fidl_next::wire::Box::encode_present(out);
7081            } else {
7082                ::fidl_next::wire::Box::encode_absent(out);
7083            }
7084
7085            Ok(())
7086        }
7087    }
7088
7089    unsafe impl<'a, ___E>
7090        ::fidl_next::EncodeOption<
7091            ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7092            ___E,
7093        > for &'a NodeGetAttributesRequest
7094    where
7095        ___E: ::fidl_next::Encoder + ?Sized,
7096        &'a NodeGetAttributesRequest:
7097            ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>,
7098    {
7099        #[inline]
7100        fn encode_option(
7101            this: ::core::option::Option<Self>,
7102            encoder: &mut ___E,
7103            out: &mut ::core::mem::MaybeUninit<
7104                ::fidl_next::wire::Box<'static, crate::wire::NodeGetAttributesRequest>,
7105            >,
7106            _: (),
7107        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7108            if let Some(inner) = this {
7109                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7110                ::fidl_next::wire::Box::encode_present(out);
7111            } else {
7112                ::fidl_next::wire::Box::encode_absent(out);
7113            }
7114
7115            Ok(())
7116        }
7117    }
7118
7119    impl ::fidl_next::FromWire<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
7120        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7121            crate::wire::NodeGetAttributesRequest,
7122            Self,
7123        > = unsafe {
7124            ::fidl_next::CopyOptimization::enable_if(
7125                true && <crate::natural::NodeAttributesQuery as ::fidl_next::FromWire<
7126                    crate::wire::NodeAttributesQuery,
7127                >>::COPY_OPTIMIZATION
7128                    .is_enabled(),
7129            )
7130        };
7131
7132        #[inline]
7133        fn from_wire(wire: crate::wire::NodeGetAttributesRequest) -> Self {
7134            Self { query: ::fidl_next::FromWire::from_wire(wire.query) }
7135        }
7136    }
7137
7138    impl ::fidl_next::FromWireRef<crate::wire::NodeGetAttributesRequest> for NodeGetAttributesRequest {
7139        #[inline]
7140        fn from_wire_ref(wire: &crate::wire::NodeGetAttributesRequest) -> Self {
7141            Self { query: ::fidl_next::FromWireRef::from_wire_ref(&wire.query) }
7142        }
7143    }
7144
7145    #[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"]
7146    #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7147    pub struct Options {
7148        pub attributes: ::core::option::Option<crate::natural::NodeAttributesQuery>,
7149
7150        pub create_attributes: ::core::option::Option<crate::natural::MutableNodeAttributes>,
7151    }
7152
7153    impl Options {
7154        fn __max_ordinal(&self) -> usize {
7155            if self.create_attributes.is_some() {
7156                return 2;
7157            }
7158
7159            if self.attributes.is_some() {
7160                return 1;
7161            }
7162
7163            0
7164        }
7165    }
7166
7167    unsafe impl<___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for Options
7168    where
7169        ___E: ::fidl_next::Encoder + ?Sized,
7170    {
7171        #[inline]
7172        fn encode(
7173            mut self,
7174            encoder: &mut ___E,
7175            out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
7176            _: (),
7177        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7178            ::fidl_next::munge!(let crate::wire::Options { table } = out);
7179
7180            let max_ord = self.__max_ordinal();
7181
7182            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7183            ::fidl_next::Wire::zero_padding(&mut out);
7184
7185            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7186                ::fidl_next::wire::Envelope,
7187            >(encoder, max_ord);
7188
7189            for i in 1..=max_ord {
7190                match i {
7191                    2 => {
7192                        if let Some(value) = self.create_attributes.take() {
7193                            ::fidl_next::wire::Envelope::encode_value::<
7194                                crate::wire::MutableNodeAttributes<'static>,
7195                                ___E,
7196                            >(
7197                                value, preallocated.encoder, &mut out, ()
7198                            )?;
7199                        } else {
7200                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7201                        }
7202                    }
7203
7204                    1 => {
7205                        if let Some(value) = self.attributes.take() {
7206                            ::fidl_next::wire::Envelope::encode_value::<
7207                                crate::wire::NodeAttributesQuery,
7208                                ___E,
7209                            >(
7210                                value, preallocated.encoder, &mut out, ()
7211                            )?;
7212                        } else {
7213                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7214                        }
7215                    }
7216
7217                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7218                }
7219                unsafe {
7220                    preallocated.write_next(out.assume_init_ref());
7221                }
7222            }
7223
7224            ::fidl_next::wire::Table::encode_len(table, max_ord);
7225
7226            Ok(())
7227        }
7228    }
7229
7230    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Options<'static>, ___E> for &'a Options
7231    where
7232        ___E: ::fidl_next::Encoder + ?Sized,
7233    {
7234        #[inline]
7235        fn encode(
7236            self,
7237            encoder: &mut ___E,
7238            out: &mut ::core::mem::MaybeUninit<crate::wire::Options<'static>>,
7239            _: (),
7240        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7241            ::fidl_next::munge!(let crate::wire::Options { table } = out);
7242
7243            let max_ord = self.__max_ordinal();
7244
7245            let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
7246            ::fidl_next::Wire::zero_padding(&mut out);
7247
7248            let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
7249                ::fidl_next::wire::Envelope,
7250            >(encoder, max_ord);
7251
7252            for i in 1..=max_ord {
7253                match i {
7254                    2 => {
7255                        if let Some(value) = &self.create_attributes {
7256                            ::fidl_next::wire::Envelope::encode_value::<
7257                                crate::wire::MutableNodeAttributes<'static>,
7258                                ___E,
7259                            >(
7260                                value, preallocated.encoder, &mut out, ()
7261                            )?;
7262                        } else {
7263                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7264                        }
7265                    }
7266
7267                    1 => {
7268                        if let Some(value) = &self.attributes {
7269                            ::fidl_next::wire::Envelope::encode_value::<
7270                                crate::wire::NodeAttributesQuery,
7271                                ___E,
7272                            >(
7273                                value, preallocated.encoder, &mut out, ()
7274                            )?;
7275                        } else {
7276                            ::fidl_next::wire::Envelope::encode_zero(&mut out)
7277                        }
7278                    }
7279
7280                    _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
7281                }
7282                unsafe {
7283                    preallocated.write_next(out.assume_init_ref());
7284                }
7285            }
7286
7287            ::fidl_next::wire::Table::encode_len(table, max_ord);
7288
7289            Ok(())
7290        }
7291    }
7292
7293    impl<'de> ::fidl_next::FromWire<crate::wire::Options<'de>> for Options {
7294        #[inline]
7295        fn from_wire(wire_: crate::wire::Options<'de>) -> Self {
7296            let wire_ = ::core::mem::ManuallyDrop::new(wire_);
7297
7298            let attributes = wire_.table.get(1);
7299
7300            let create_attributes = wire_.table.get(2);
7301
7302            Self {
7303                attributes: attributes.map(|envelope| {
7304                    ::fidl_next::FromWire::from_wire(unsafe {
7305                        envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
7306                    })
7307                }),
7308
7309                create_attributes: create_attributes.map(|envelope| {
7310                    ::fidl_next::FromWire::from_wire(unsafe {
7311                        envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
7312                    })
7313                }),
7314            }
7315        }
7316    }
7317
7318    impl<'de> ::fidl_next::FromWireRef<crate::wire::Options<'de>> for Options {
7319        #[inline]
7320        fn from_wire_ref(wire: &crate::wire::Options<'de>) -> Self {
7321            Self {
7322                attributes: wire.table.get(1).map(|envelope| {
7323                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7324                        envelope.deref_unchecked::<crate::wire::NodeAttributesQuery>()
7325                    })
7326                }),
7327
7328                create_attributes: wire.table.get(2).map(|envelope| {
7329                    ::fidl_next::FromWireRef::from_wire_ref(unsafe {
7330                        envelope.deref_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
7331                    })
7332                }),
7333            }
7334        }
7335    }
7336
7337    pub type DirectoryObject = ();
7338
7339    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7340    #[repr(u8)]
7341    pub enum DirentType {
7342        Unknown = 0,
7343        Directory = 4,
7344        BlockDevice = 6,
7345        File = 8,
7346        Symlink = 10,
7347        Service = 16,
7348        UnknownOrdinal_(u8) = 17,
7349    }
7350    impl ::std::convert::From<u8> for DirentType {
7351        fn from(value: u8) -> Self {
7352            match value {
7353                0 => Self::Unknown,
7354                4 => Self::Directory,
7355                6 => Self::BlockDevice,
7356                8 => Self::File,
7357                10 => Self::Symlink,
7358                16 => Self::Service,
7359
7360                _ => Self::UnknownOrdinal_(value),
7361            }
7362        }
7363    }
7364
7365    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for DirentType
7366    where
7367        ___E: ?Sized,
7368    {
7369        #[inline]
7370        fn encode(
7371            self,
7372            encoder: &mut ___E,
7373            out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
7374            _: (),
7375        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7376            ::fidl_next::Encode::encode(&self, encoder, out, ())
7377        }
7378    }
7379
7380    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DirentType, ___E> for &'a DirentType
7381    where
7382        ___E: ?Sized,
7383    {
7384        #[inline]
7385        fn encode(
7386            self,
7387            encoder: &mut ___E,
7388            out: &mut ::core::mem::MaybeUninit<crate::wire::DirentType>,
7389            _: (),
7390        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7391            ::fidl_next::munge!(let crate::wire::DirentType { value } = out);
7392            let _ = value.write(u8::from(match *self {
7393                DirentType::Unknown => 0,
7394
7395                DirentType::Directory => 4,
7396
7397                DirentType::BlockDevice => 6,
7398
7399                DirentType::File => 8,
7400
7401                DirentType::Symlink => 10,
7402
7403                DirentType::Service => 16,
7404
7405                DirentType::UnknownOrdinal_(value) => value,
7406            }));
7407
7408            Ok(())
7409        }
7410    }
7411
7412    impl ::core::convert::From<crate::wire::DirentType> for DirentType {
7413        fn from(wire: crate::wire::DirentType) -> Self {
7414            match u8::from(wire.value) {
7415                0 => Self::Unknown,
7416
7417                4 => Self::Directory,
7418
7419                6 => Self::BlockDevice,
7420
7421                8 => Self::File,
7422
7423                10 => Self::Symlink,
7424
7425                16 => Self::Service,
7426
7427                value => Self::UnknownOrdinal_(value),
7428            }
7429        }
7430    }
7431
7432    impl ::fidl_next::FromWire<crate::wire::DirentType> for DirentType {
7433        #[inline]
7434        fn from_wire(wire: crate::wire::DirentType) -> Self {
7435            Self::from(wire)
7436        }
7437    }
7438
7439    impl ::fidl_next::FromWireRef<crate::wire::DirentType> for DirentType {
7440        #[inline]
7441        fn from_wire_ref(wire: &crate::wire::DirentType) -> Self {
7442            Self::from(*wire)
7443        }
7444    }
7445
7446    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7447    pub struct ExtendedAttributeIteratorGetNextResponse {
7448        pub attributes: ::std::vec::Vec<::std::vec::Vec<u8>>,
7449
7450        pub last: bool,
7451    }
7452
7453    unsafe impl<___E>
7454        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
7455        for ExtendedAttributeIteratorGetNextResponse
7456    where
7457        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7458        ___E: ::fidl_next::Encoder,
7459    {
7460        #[inline]
7461        fn encode(
7462            self,
7463            encoder_: &mut ___E,
7464            out_: &mut ::core::mem::MaybeUninit<
7465                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7466            >,
7467            _: (),
7468        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7469            ::fidl_next::munge! {
7470                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
7471                    attributes,
7472                    last,
7473
7474                } = out_;
7475            }
7476
7477            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
7478
7479            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
7480            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
7481
7482            ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
7483
7484            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
7485
7486            Ok(())
7487        }
7488    }
7489
7490    unsafe impl<'a, ___E>
7491        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
7492        for &'a ExtendedAttributeIteratorGetNextResponse
7493    where
7494        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7495        ___E: ::fidl_next::Encoder,
7496    {
7497        #[inline]
7498        fn encode(
7499            self,
7500            encoder_: &mut ___E,
7501            out_: &mut ::core::mem::MaybeUninit<
7502                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7503            >,
7504            _: (),
7505        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7506            ::fidl_next::munge! {
7507                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
7508                    attributes,
7509                    last,
7510
7511                } = out_;
7512            }
7513
7514            ::fidl_next::Encode::encode(&self.attributes, encoder_, attributes, (128, (255, ())))?;
7515
7516            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(attributes.as_mut_ptr()) };
7517            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
7518
7519            ::fidl_next::Encode::encode(&self.last, encoder_, last, ())?;
7520
7521            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(last.as_mut_ptr()) };
7522
7523            Ok(())
7524        }
7525    }
7526
7527    unsafe impl<___E>
7528        ::fidl_next::EncodeOption<
7529            ::fidl_next::wire::Box<
7530                'static,
7531                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7532            >,
7533            ___E,
7534        > for ExtendedAttributeIteratorGetNextResponse
7535    where
7536        ___E: ::fidl_next::Encoder + ?Sized,
7537        ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
7538                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7539                ___E,
7540            >,
7541    {
7542        #[inline]
7543        fn encode_option(
7544            this: ::core::option::Option<Self>,
7545            encoder: &mut ___E,
7546            out: &mut ::core::mem::MaybeUninit<
7547                ::fidl_next::wire::Box<
7548                    'static,
7549                    crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7550                >,
7551            >,
7552            _: (),
7553        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7554            if let Some(inner) = this {
7555                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7556                ::fidl_next::wire::Box::encode_present(out);
7557            } else {
7558                ::fidl_next::wire::Box::encode_absent(out);
7559            }
7560
7561            Ok(())
7562        }
7563    }
7564
7565    unsafe impl<'a, ___E>
7566        ::fidl_next::EncodeOption<
7567            ::fidl_next::wire::Box<
7568                'static,
7569                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7570            >,
7571            ___E,
7572        > for &'a ExtendedAttributeIteratorGetNextResponse
7573    where
7574        ___E: ::fidl_next::Encoder + ?Sized,
7575        &'a ExtendedAttributeIteratorGetNextResponse: ::fidl_next::Encode<
7576                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7577                ___E,
7578            >,
7579    {
7580        #[inline]
7581        fn encode_option(
7582            this: ::core::option::Option<Self>,
7583            encoder: &mut ___E,
7584            out: &mut ::core::mem::MaybeUninit<
7585                ::fidl_next::wire::Box<
7586                    'static,
7587                    crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
7588                >,
7589            >,
7590            _: (),
7591        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7592            if let Some(inner) = this {
7593                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7594                ::fidl_next::wire::Box::encode_present(out);
7595            } else {
7596                ::fidl_next::wire::Box::encode_absent(out);
7597            }
7598
7599            Ok(())
7600        }
7601    }
7602
7603    impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
7604        for ExtendedAttributeIteratorGetNextResponse
7605    {
7606        #[inline]
7607        fn from_wire(wire: crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>) -> Self {
7608            Self {
7609                attributes: ::fidl_next::FromWire::from_wire(wire.attributes),
7610
7611                last: ::fidl_next::FromWire::from_wire(wire.last),
7612            }
7613        }
7614    }
7615
7616    impl<'de> ::fidl_next::FromWireRef<crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>>
7617        for ExtendedAttributeIteratorGetNextResponse
7618    {
7619        #[inline]
7620        fn from_wire_ref(
7621            wire: &crate::wire::ExtendedAttributeIteratorGetNextResponse<'de>,
7622        ) -> Self {
7623            Self {
7624                attributes: ::fidl_next::FromWireRef::from_wire_ref(&wire.attributes),
7625
7626                last: ::fidl_next::FromWireRef::from_wire_ref(&wire.last),
7627            }
7628        }
7629    }
7630
7631    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7632    #[repr(C)]
7633    pub struct ReadableReadRequest {
7634        pub count: u64,
7635    }
7636
7637    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
7638        for ReadableReadRequest
7639    where
7640        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7641    {
7642        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7643            Self,
7644            crate::wire::ReadableReadRequest,
7645        > = unsafe {
7646            ::fidl_next::CopyOptimization::enable_if(
7647            true
7648
7649                && <
7650                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
7651                >::COPY_OPTIMIZATION.is_enabled()
7652
7653        )
7654        };
7655
7656        #[inline]
7657        fn encode(
7658            self,
7659            encoder_: &mut ___E,
7660            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
7661            _: (),
7662        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7663            ::fidl_next::munge! {
7664                let crate::wire::ReadableReadRequest {
7665                    count,
7666
7667                } = out_;
7668            }
7669
7670            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
7671
7672            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
7673
7674            Ok(())
7675        }
7676    }
7677
7678    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
7679        for &'a ReadableReadRequest
7680    where
7681        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7682    {
7683        #[inline]
7684        fn encode(
7685            self,
7686            encoder_: &mut ___E,
7687            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
7688            _: (),
7689        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7690            ::fidl_next::munge! {
7691                let crate::wire::ReadableReadRequest {
7692                    count,
7693
7694                } = out_;
7695            }
7696
7697            ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
7698
7699            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
7700
7701            Ok(())
7702        }
7703    }
7704
7705    unsafe impl<___E>
7706        ::fidl_next::EncodeOption<
7707            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7708            ___E,
7709        > for ReadableReadRequest
7710    where
7711        ___E: ::fidl_next::Encoder + ?Sized,
7712        ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
7713    {
7714        #[inline]
7715        fn encode_option(
7716            this: ::core::option::Option<Self>,
7717            encoder: &mut ___E,
7718            out: &mut ::core::mem::MaybeUninit<
7719                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7720            >,
7721            _: (),
7722        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7723            if let Some(inner) = this {
7724                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7725                ::fidl_next::wire::Box::encode_present(out);
7726            } else {
7727                ::fidl_next::wire::Box::encode_absent(out);
7728            }
7729
7730            Ok(())
7731        }
7732    }
7733
7734    unsafe impl<'a, ___E>
7735        ::fidl_next::EncodeOption<
7736            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7737            ___E,
7738        > for &'a ReadableReadRequest
7739    where
7740        ___E: ::fidl_next::Encoder + ?Sized,
7741        &'a ReadableReadRequest: ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>,
7742    {
7743        #[inline]
7744        fn encode_option(
7745            this: ::core::option::Option<Self>,
7746            encoder: &mut ___E,
7747            out: &mut ::core::mem::MaybeUninit<
7748                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadRequest>,
7749            >,
7750            _: (),
7751        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7752            if let Some(inner) = this {
7753                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7754                ::fidl_next::wire::Box::encode_present(out);
7755            } else {
7756                ::fidl_next::wire::Box::encode_absent(out);
7757            }
7758
7759            Ok(())
7760        }
7761    }
7762
7763    impl ::fidl_next::FromWire<crate::wire::ReadableReadRequest> for ReadableReadRequest {
7764        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
7765            crate::wire::ReadableReadRequest,
7766            Self,
7767        > = unsafe {
7768            ::fidl_next::CopyOptimization::enable_if(
7769                true
7770                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
7771                        .is_enabled(),
7772            )
7773        };
7774
7775        #[inline]
7776        fn from_wire(wire: crate::wire::ReadableReadRequest) -> Self {
7777            Self { count: ::fidl_next::FromWire::from_wire(wire.count) }
7778        }
7779    }
7780
7781    impl ::fidl_next::FromWireRef<crate::wire::ReadableReadRequest> for ReadableReadRequest {
7782        #[inline]
7783        fn from_wire_ref(wire: &crate::wire::ReadableReadRequest) -> Self {
7784            Self { count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count) }
7785        }
7786    }
7787
7788    #[doc = " The byte vector type used for read/write operations.\n"]
7789    pub type Transfer = ::std::vec::Vec<u8>;
7790
7791    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7792    pub struct ReadableReadResponse {
7793        pub data: ::std::vec::Vec<u8>,
7794    }
7795
7796    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
7797        for ReadableReadResponse
7798    where
7799        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7800        ___E: ::fidl_next::Encoder,
7801    {
7802        #[inline]
7803        fn encode(
7804            self,
7805            encoder_: &mut ___E,
7806            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
7807            _: (),
7808        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7809            ::fidl_next::munge! {
7810                let crate::wire::ReadableReadResponse {
7811                    data,
7812
7813                } = out_;
7814            }
7815
7816            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
7817
7818            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7819            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7820
7821            Ok(())
7822        }
7823    }
7824
7825    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
7826        for &'a ReadableReadResponse
7827    where
7828        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7829        ___E: ::fidl_next::Encoder,
7830    {
7831        #[inline]
7832        fn encode(
7833            self,
7834            encoder_: &mut ___E,
7835            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
7836            _: (),
7837        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7838            ::fidl_next::munge! {
7839                let crate::wire::ReadableReadResponse {
7840                    data,
7841
7842                } = out_;
7843            }
7844
7845            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
7846
7847            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7848            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7849
7850            Ok(())
7851        }
7852    }
7853
7854    unsafe impl<___E>
7855        ::fidl_next::EncodeOption<
7856            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7857            ___E,
7858        > for ReadableReadResponse
7859    where
7860        ___E: ::fidl_next::Encoder + ?Sized,
7861        ReadableReadResponse: ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
7862    {
7863        #[inline]
7864        fn encode_option(
7865            this: ::core::option::Option<Self>,
7866            encoder: &mut ___E,
7867            out: &mut ::core::mem::MaybeUninit<
7868                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7869            >,
7870            _: (),
7871        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7872            if let Some(inner) = this {
7873                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7874                ::fidl_next::wire::Box::encode_present(out);
7875            } else {
7876                ::fidl_next::wire::Box::encode_absent(out);
7877            }
7878
7879            Ok(())
7880        }
7881    }
7882
7883    unsafe impl<'a, ___E>
7884        ::fidl_next::EncodeOption<
7885            ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7886            ___E,
7887        > for &'a ReadableReadResponse
7888    where
7889        ___E: ::fidl_next::Encoder + ?Sized,
7890        &'a ReadableReadResponse:
7891            ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>,
7892    {
7893        #[inline]
7894        fn encode_option(
7895            this: ::core::option::Option<Self>,
7896            encoder: &mut ___E,
7897            out: &mut ::core::mem::MaybeUninit<
7898                ::fidl_next::wire::Box<'static, crate::wire::ReadableReadResponse<'static>>,
7899            >,
7900            _: (),
7901        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7902            if let Some(inner) = this {
7903                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
7904                ::fidl_next::wire::Box::encode_present(out);
7905            } else {
7906                ::fidl_next::wire::Box::encode_absent(out);
7907            }
7908
7909            Ok(())
7910        }
7911    }
7912
7913    impl<'de> ::fidl_next::FromWire<crate::wire::ReadableReadResponse<'de>> for ReadableReadResponse {
7914        #[inline]
7915        fn from_wire(wire: crate::wire::ReadableReadResponse<'de>) -> Self {
7916            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
7917        }
7918    }
7919
7920    impl<'de> ::fidl_next::FromWireRef<crate::wire::ReadableReadResponse<'de>>
7921        for ReadableReadResponse
7922    {
7923        #[inline]
7924        fn from_wire_ref(wire: &crate::wire::ReadableReadResponse<'de>) -> Self {
7925            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
7926        }
7927    }
7928
7929    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
7930    pub struct WritableWriteRequest {
7931        pub data: ::std::vec::Vec<u8>,
7932    }
7933
7934    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
7935        for WritableWriteRequest
7936    where
7937        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7938        ___E: ::fidl_next::Encoder,
7939    {
7940        #[inline]
7941        fn encode(
7942            self,
7943            encoder_: &mut ___E,
7944            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
7945            _: (),
7946        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7947            ::fidl_next::munge! {
7948                let crate::wire::WritableWriteRequest {
7949                    data,
7950
7951                } = out_;
7952            }
7953
7954            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
7955
7956            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7957            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7958
7959            Ok(())
7960        }
7961    }
7962
7963    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
7964        for &'a WritableWriteRequest
7965    where
7966        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7967        ___E: ::fidl_next::Encoder,
7968    {
7969        #[inline]
7970        fn encode(
7971            self,
7972            encoder_: &mut ___E,
7973            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
7974            _: (),
7975        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7976            ::fidl_next::munge! {
7977                let crate::wire::WritableWriteRequest {
7978                    data,
7979
7980                } = out_;
7981            }
7982
7983            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
7984
7985            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
7986            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
7987
7988            Ok(())
7989        }
7990    }
7991
7992    unsafe impl<___E>
7993        ::fidl_next::EncodeOption<
7994            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
7995            ___E,
7996        > for WritableWriteRequest
7997    where
7998        ___E: ::fidl_next::Encoder + ?Sized,
7999        WritableWriteRequest: ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
8000    {
8001        #[inline]
8002        fn encode_option(
8003            this: ::core::option::Option<Self>,
8004            encoder: &mut ___E,
8005            out: &mut ::core::mem::MaybeUninit<
8006                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8007            >,
8008            _: (),
8009        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8010            if let Some(inner) = this {
8011                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8012                ::fidl_next::wire::Box::encode_present(out);
8013            } else {
8014                ::fidl_next::wire::Box::encode_absent(out);
8015            }
8016
8017            Ok(())
8018        }
8019    }
8020
8021    unsafe impl<'a, ___E>
8022        ::fidl_next::EncodeOption<
8023            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8024            ___E,
8025        > for &'a WritableWriteRequest
8026    where
8027        ___E: ::fidl_next::Encoder + ?Sized,
8028        &'a WritableWriteRequest:
8029            ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>,
8030    {
8031        #[inline]
8032        fn encode_option(
8033            this: ::core::option::Option<Self>,
8034            encoder: &mut ___E,
8035            out: &mut ::core::mem::MaybeUninit<
8036                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteRequest<'static>>,
8037            >,
8038            _: (),
8039        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8040            if let Some(inner) = this {
8041                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8042                ::fidl_next::wire::Box::encode_present(out);
8043            } else {
8044                ::fidl_next::wire::Box::encode_absent(out);
8045            }
8046
8047            Ok(())
8048        }
8049    }
8050
8051    impl<'de> ::fidl_next::FromWire<crate::wire::WritableWriteRequest<'de>> for WritableWriteRequest {
8052        #[inline]
8053        fn from_wire(wire: crate::wire::WritableWriteRequest<'de>) -> Self {
8054            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
8055        }
8056    }
8057
8058    impl<'de> ::fidl_next::FromWireRef<crate::wire::WritableWriteRequest<'de>>
8059        for WritableWriteRequest
8060    {
8061        #[inline]
8062        fn from_wire_ref(wire: &crate::wire::WritableWriteRequest<'de>) -> Self {
8063            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
8064        }
8065    }
8066
8067    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8068    #[repr(C)]
8069    pub struct WritableWriteResponse {
8070        pub actual_count: u64,
8071    }
8072
8073    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
8074        for WritableWriteResponse
8075    where
8076        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8077    {
8078        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8079            Self,
8080            crate::wire::WritableWriteResponse,
8081        > = unsafe {
8082            ::fidl_next::CopyOptimization::enable_if(
8083            true
8084
8085                && <
8086                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8087                >::COPY_OPTIMIZATION.is_enabled()
8088
8089        )
8090        };
8091
8092        #[inline]
8093        fn encode(
8094            self,
8095            encoder_: &mut ___E,
8096            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
8097            _: (),
8098        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8099            ::fidl_next::munge! {
8100                let crate::wire::WritableWriteResponse {
8101                    actual_count,
8102
8103                } = out_;
8104            }
8105
8106            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
8107
8108            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
8109
8110            Ok(())
8111        }
8112    }
8113
8114    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
8115        for &'a WritableWriteResponse
8116    where
8117        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8118    {
8119        #[inline]
8120        fn encode(
8121            self,
8122            encoder_: &mut ___E,
8123            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
8124            _: (),
8125        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8126            ::fidl_next::munge! {
8127                let crate::wire::WritableWriteResponse {
8128                    actual_count,
8129
8130                } = out_;
8131            }
8132
8133            ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
8134
8135            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
8136
8137            Ok(())
8138        }
8139    }
8140
8141    unsafe impl<___E>
8142        ::fidl_next::EncodeOption<
8143            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8144            ___E,
8145        > for WritableWriteResponse
8146    where
8147        ___E: ::fidl_next::Encoder + ?Sized,
8148        WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
8149    {
8150        #[inline]
8151        fn encode_option(
8152            this: ::core::option::Option<Self>,
8153            encoder: &mut ___E,
8154            out: &mut ::core::mem::MaybeUninit<
8155                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8156            >,
8157            _: (),
8158        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8159            if let Some(inner) = this {
8160                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8161                ::fidl_next::wire::Box::encode_present(out);
8162            } else {
8163                ::fidl_next::wire::Box::encode_absent(out);
8164            }
8165
8166            Ok(())
8167        }
8168    }
8169
8170    unsafe impl<'a, ___E>
8171        ::fidl_next::EncodeOption<
8172            ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8173            ___E,
8174        > for &'a WritableWriteResponse
8175    where
8176        ___E: ::fidl_next::Encoder + ?Sized,
8177        &'a WritableWriteResponse: ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>,
8178    {
8179        #[inline]
8180        fn encode_option(
8181            this: ::core::option::Option<Self>,
8182            encoder: &mut ___E,
8183            out: &mut ::core::mem::MaybeUninit<
8184                ::fidl_next::wire::Box<'static, crate::wire::WritableWriteResponse>,
8185            >,
8186            _: (),
8187        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8188            if let Some(inner) = this {
8189                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8190                ::fidl_next::wire::Box::encode_present(out);
8191            } else {
8192                ::fidl_next::wire::Box::encode_absent(out);
8193            }
8194
8195            Ok(())
8196        }
8197    }
8198
8199    impl ::fidl_next::FromWire<crate::wire::WritableWriteResponse> for WritableWriteResponse {
8200        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8201            crate::wire::WritableWriteResponse,
8202            Self,
8203        > = unsafe {
8204            ::fidl_next::CopyOptimization::enable_if(
8205                true
8206                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8207                        .is_enabled(),
8208            )
8209        };
8210
8211        #[inline]
8212        fn from_wire(wire: crate::wire::WritableWriteResponse) -> Self {
8213            Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
8214        }
8215    }
8216
8217    impl ::fidl_next::FromWireRef<crate::wire::WritableWriteResponse> for WritableWriteResponse {
8218        #[inline]
8219        fn from_wire_ref(wire: &crate::wire::WritableWriteResponse) -> Self {
8220            Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
8221        }
8222    }
8223
8224    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8225    pub struct FileSeekRequest {
8226        pub origin: crate::natural::SeekOrigin,
8227
8228        pub offset: i64,
8229    }
8230
8231    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E> for FileSeekRequest
8232    where
8233        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8234    {
8235        #[inline]
8236        fn encode(
8237            self,
8238            encoder_: &mut ___E,
8239            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
8240            _: (),
8241        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8242            ::fidl_next::munge! {
8243                let crate::wire::FileSeekRequest {
8244                    origin,
8245                    offset,
8246
8247                } = out_;
8248            }
8249
8250            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
8251
8252            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
8253
8254            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8255
8256            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8257
8258            Ok(())
8259        }
8260    }
8261
8262    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
8263        for &'a FileSeekRequest
8264    where
8265        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8266    {
8267        #[inline]
8268        fn encode(
8269            self,
8270            encoder_: &mut ___E,
8271            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
8272            _: (),
8273        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8274            ::fidl_next::munge! {
8275                let crate::wire::FileSeekRequest {
8276                    origin,
8277                    offset,
8278
8279                } = out_;
8280            }
8281
8282            ::fidl_next::Encode::encode(&self.origin, encoder_, origin, ())?;
8283
8284            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(origin.as_mut_ptr()) };
8285
8286            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8287
8288            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8289
8290            Ok(())
8291        }
8292    }
8293
8294    unsafe impl<___E>
8295        ::fidl_next::EncodeOption<
8296            ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8297            ___E,
8298        > for FileSeekRequest
8299    where
8300        ___E: ::fidl_next::Encoder + ?Sized,
8301        FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
8302    {
8303        #[inline]
8304        fn encode_option(
8305            this: ::core::option::Option<Self>,
8306            encoder: &mut ___E,
8307            out: &mut ::core::mem::MaybeUninit<
8308                ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8309            >,
8310            _: (),
8311        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8312            if let Some(inner) = this {
8313                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8314                ::fidl_next::wire::Box::encode_present(out);
8315            } else {
8316                ::fidl_next::wire::Box::encode_absent(out);
8317            }
8318
8319            Ok(())
8320        }
8321    }
8322
8323    unsafe impl<'a, ___E>
8324        ::fidl_next::EncodeOption<
8325            ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8326            ___E,
8327        > for &'a FileSeekRequest
8328    where
8329        ___E: ::fidl_next::Encoder + ?Sized,
8330        &'a FileSeekRequest: ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>,
8331    {
8332        #[inline]
8333        fn encode_option(
8334            this: ::core::option::Option<Self>,
8335            encoder: &mut ___E,
8336            out: &mut ::core::mem::MaybeUninit<
8337                ::fidl_next::wire::Box<'static, crate::wire::FileSeekRequest>,
8338            >,
8339            _: (),
8340        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8341            if let Some(inner) = this {
8342                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8343                ::fidl_next::wire::Box::encode_present(out);
8344            } else {
8345                ::fidl_next::wire::Box::encode_absent(out);
8346            }
8347
8348            Ok(())
8349        }
8350    }
8351
8352    impl ::fidl_next::FromWire<crate::wire::FileSeekRequest> for FileSeekRequest {
8353        #[inline]
8354        fn from_wire(wire: crate::wire::FileSeekRequest) -> Self {
8355            Self {
8356                origin: ::fidl_next::FromWire::from_wire(wire.origin),
8357
8358                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8359            }
8360        }
8361    }
8362
8363    impl ::fidl_next::FromWireRef<crate::wire::FileSeekRequest> for FileSeekRequest {
8364        #[inline]
8365        fn from_wire_ref(wire: &crate::wire::FileSeekRequest) -> Self {
8366            Self {
8367                origin: ::fidl_next::FromWireRef::from_wire_ref(&wire.origin),
8368
8369                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
8370            }
8371        }
8372    }
8373
8374    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8375    #[repr(C)]
8376    pub struct FileSeekResponse {
8377        pub offset_from_start: u64,
8378    }
8379
8380    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E> for FileSeekResponse
8381    where
8382        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8383    {
8384        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8385            Self,
8386            crate::wire::FileSeekResponse,
8387        > = unsafe {
8388            ::fidl_next::CopyOptimization::enable_if(
8389            true
8390
8391                && <
8392                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8393                >::COPY_OPTIMIZATION.is_enabled()
8394
8395        )
8396        };
8397
8398        #[inline]
8399        fn encode(
8400            self,
8401            encoder_: &mut ___E,
8402            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
8403            _: (),
8404        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8405            ::fidl_next::munge! {
8406                let crate::wire::FileSeekResponse {
8407                    offset_from_start,
8408
8409                } = out_;
8410            }
8411
8412            ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
8413
8414            let mut _field =
8415                unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
8416
8417            Ok(())
8418        }
8419    }
8420
8421    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
8422        for &'a FileSeekResponse
8423    where
8424        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8425    {
8426        #[inline]
8427        fn encode(
8428            self,
8429            encoder_: &mut ___E,
8430            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
8431            _: (),
8432        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8433            ::fidl_next::munge! {
8434                let crate::wire::FileSeekResponse {
8435                    offset_from_start,
8436
8437                } = out_;
8438            }
8439
8440            ::fidl_next::Encode::encode(&self.offset_from_start, encoder_, offset_from_start, ())?;
8441
8442            let mut _field =
8443                unsafe { ::fidl_next::Slot::new_unchecked(offset_from_start.as_mut_ptr()) };
8444
8445            Ok(())
8446        }
8447    }
8448
8449    unsafe impl<___E>
8450        ::fidl_next::EncodeOption<
8451            ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8452            ___E,
8453        > for FileSeekResponse
8454    where
8455        ___E: ::fidl_next::Encoder + ?Sized,
8456        FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
8457    {
8458        #[inline]
8459        fn encode_option(
8460            this: ::core::option::Option<Self>,
8461            encoder: &mut ___E,
8462            out: &mut ::core::mem::MaybeUninit<
8463                ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8464            >,
8465            _: (),
8466        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8467            if let Some(inner) = this {
8468                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8469                ::fidl_next::wire::Box::encode_present(out);
8470            } else {
8471                ::fidl_next::wire::Box::encode_absent(out);
8472            }
8473
8474            Ok(())
8475        }
8476    }
8477
8478    unsafe impl<'a, ___E>
8479        ::fidl_next::EncodeOption<
8480            ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8481            ___E,
8482        > for &'a FileSeekResponse
8483    where
8484        ___E: ::fidl_next::Encoder + ?Sized,
8485        &'a FileSeekResponse: ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>,
8486    {
8487        #[inline]
8488        fn encode_option(
8489            this: ::core::option::Option<Self>,
8490            encoder: &mut ___E,
8491            out: &mut ::core::mem::MaybeUninit<
8492                ::fidl_next::wire::Box<'static, crate::wire::FileSeekResponse>,
8493            >,
8494            _: (),
8495        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8496            if let Some(inner) = this {
8497                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8498                ::fidl_next::wire::Box::encode_present(out);
8499            } else {
8500                ::fidl_next::wire::Box::encode_absent(out);
8501            }
8502
8503            Ok(())
8504        }
8505    }
8506
8507    impl ::fidl_next::FromWire<crate::wire::FileSeekResponse> for FileSeekResponse {
8508        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8509            crate::wire::FileSeekResponse,
8510            Self,
8511        > = unsafe {
8512            ::fidl_next::CopyOptimization::enable_if(
8513                true
8514                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8515                        .is_enabled(),
8516            )
8517        };
8518
8519        #[inline]
8520        fn from_wire(wire: crate::wire::FileSeekResponse) -> Self {
8521            Self { offset_from_start: ::fidl_next::FromWire::from_wire(wire.offset_from_start) }
8522        }
8523    }
8524
8525    impl ::fidl_next::FromWireRef<crate::wire::FileSeekResponse> for FileSeekResponse {
8526        #[inline]
8527        fn from_wire_ref(wire: &crate::wire::FileSeekResponse) -> Self {
8528            Self {
8529                offset_from_start: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset_from_start),
8530            }
8531        }
8532    }
8533
8534    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8535    #[repr(C)]
8536    pub struct FileReadAtRequest {
8537        pub count: u64,
8538
8539        pub offset: u64,
8540    }
8541
8542    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E> for FileReadAtRequest
8543    where
8544        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8545    {
8546        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8547            Self,
8548            crate::wire::FileReadAtRequest,
8549        > = unsafe {
8550            ::fidl_next::CopyOptimization::enable_if(
8551            true
8552
8553                && <
8554                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8555                >::COPY_OPTIMIZATION.is_enabled()
8556
8557                && <
8558                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
8559                >::COPY_OPTIMIZATION.is_enabled()
8560
8561        )
8562        };
8563
8564        #[inline]
8565        fn encode(
8566            self,
8567            encoder_: &mut ___E,
8568            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
8569            _: (),
8570        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8571            ::fidl_next::munge! {
8572                let crate::wire::FileReadAtRequest {
8573                    count,
8574                    offset,
8575
8576                } = out_;
8577            }
8578
8579            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
8580
8581            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
8582
8583            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8584
8585            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8586
8587            Ok(())
8588        }
8589    }
8590
8591    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
8592        for &'a FileReadAtRequest
8593    where
8594        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8595    {
8596        #[inline]
8597        fn encode(
8598            self,
8599            encoder_: &mut ___E,
8600            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
8601            _: (),
8602        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8603            ::fidl_next::munge! {
8604                let crate::wire::FileReadAtRequest {
8605                    count,
8606                    offset,
8607
8608                } = out_;
8609            }
8610
8611            ::fidl_next::Encode::encode(&self.count, encoder_, count, ())?;
8612
8613            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(count.as_mut_ptr()) };
8614
8615            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8616
8617            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8618
8619            Ok(())
8620        }
8621    }
8622
8623    unsafe impl<___E>
8624        ::fidl_next::EncodeOption<
8625            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8626            ___E,
8627        > for FileReadAtRequest
8628    where
8629        ___E: ::fidl_next::Encoder + ?Sized,
8630        FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
8631    {
8632        #[inline]
8633        fn encode_option(
8634            this: ::core::option::Option<Self>,
8635            encoder: &mut ___E,
8636            out: &mut ::core::mem::MaybeUninit<
8637                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8638            >,
8639            _: (),
8640        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8641            if let Some(inner) = this {
8642                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8643                ::fidl_next::wire::Box::encode_present(out);
8644            } else {
8645                ::fidl_next::wire::Box::encode_absent(out);
8646            }
8647
8648            Ok(())
8649        }
8650    }
8651
8652    unsafe impl<'a, ___E>
8653        ::fidl_next::EncodeOption<
8654            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8655            ___E,
8656        > for &'a FileReadAtRequest
8657    where
8658        ___E: ::fidl_next::Encoder + ?Sized,
8659        &'a FileReadAtRequest: ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>,
8660    {
8661        #[inline]
8662        fn encode_option(
8663            this: ::core::option::Option<Self>,
8664            encoder: &mut ___E,
8665            out: &mut ::core::mem::MaybeUninit<
8666                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtRequest>,
8667            >,
8668            _: (),
8669        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8670            if let Some(inner) = this {
8671                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8672                ::fidl_next::wire::Box::encode_present(out);
8673            } else {
8674                ::fidl_next::wire::Box::encode_absent(out);
8675            }
8676
8677            Ok(())
8678        }
8679    }
8680
8681    impl ::fidl_next::FromWire<crate::wire::FileReadAtRequest> for FileReadAtRequest {
8682        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
8683            crate::wire::FileReadAtRequest,
8684            Self,
8685        > = unsafe {
8686            ::fidl_next::CopyOptimization::enable_if(
8687                true
8688                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8689                        .is_enabled()
8690                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
8691                        .is_enabled(),
8692            )
8693        };
8694
8695        #[inline]
8696        fn from_wire(wire: crate::wire::FileReadAtRequest) -> Self {
8697            Self {
8698                count: ::fidl_next::FromWire::from_wire(wire.count),
8699
8700                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8701            }
8702        }
8703    }
8704
8705    impl ::fidl_next::FromWireRef<crate::wire::FileReadAtRequest> for FileReadAtRequest {
8706        #[inline]
8707        fn from_wire_ref(wire: &crate::wire::FileReadAtRequest) -> Self {
8708            Self {
8709                count: ::fidl_next::FromWireRef::from_wire_ref(&wire.count),
8710
8711                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
8712            }
8713        }
8714    }
8715
8716    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8717    pub struct FileReadAtResponse {
8718        pub data: ::std::vec::Vec<u8>,
8719    }
8720
8721    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
8722        for FileReadAtResponse
8723    where
8724        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8725        ___E: ::fidl_next::Encoder,
8726    {
8727        #[inline]
8728        fn encode(
8729            self,
8730            encoder_: &mut ___E,
8731            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
8732            _: (),
8733        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8734            ::fidl_next::munge! {
8735                let crate::wire::FileReadAtResponse {
8736                    data,
8737
8738                } = out_;
8739            }
8740
8741            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
8742
8743            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8744            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8745
8746            Ok(())
8747        }
8748    }
8749
8750    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
8751        for &'a FileReadAtResponse
8752    where
8753        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8754        ___E: ::fidl_next::Encoder,
8755    {
8756        #[inline]
8757        fn encode(
8758            self,
8759            encoder_: &mut ___E,
8760            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
8761            _: (),
8762        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8763            ::fidl_next::munge! {
8764                let crate::wire::FileReadAtResponse {
8765                    data,
8766
8767                } = out_;
8768            }
8769
8770            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
8771
8772            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8773            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8774
8775            Ok(())
8776        }
8777    }
8778
8779    unsafe impl<___E>
8780        ::fidl_next::EncodeOption<
8781            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8782            ___E,
8783        > for FileReadAtResponse
8784    where
8785        ___E: ::fidl_next::Encoder + ?Sized,
8786        FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
8787    {
8788        #[inline]
8789        fn encode_option(
8790            this: ::core::option::Option<Self>,
8791            encoder: &mut ___E,
8792            out: &mut ::core::mem::MaybeUninit<
8793                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8794            >,
8795            _: (),
8796        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8797            if let Some(inner) = this {
8798                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8799                ::fidl_next::wire::Box::encode_present(out);
8800            } else {
8801                ::fidl_next::wire::Box::encode_absent(out);
8802            }
8803
8804            Ok(())
8805        }
8806    }
8807
8808    unsafe impl<'a, ___E>
8809        ::fidl_next::EncodeOption<
8810            ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8811            ___E,
8812        > for &'a FileReadAtResponse
8813    where
8814        ___E: ::fidl_next::Encoder + ?Sized,
8815        &'a FileReadAtResponse: ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>,
8816    {
8817        #[inline]
8818        fn encode_option(
8819            this: ::core::option::Option<Self>,
8820            encoder: &mut ___E,
8821            out: &mut ::core::mem::MaybeUninit<
8822                ::fidl_next::wire::Box<'static, crate::wire::FileReadAtResponse<'static>>,
8823            >,
8824            _: (),
8825        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8826            if let Some(inner) = this {
8827                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8828                ::fidl_next::wire::Box::encode_present(out);
8829            } else {
8830                ::fidl_next::wire::Box::encode_absent(out);
8831            }
8832
8833            Ok(())
8834        }
8835    }
8836
8837    impl<'de> ::fidl_next::FromWire<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
8838        #[inline]
8839        fn from_wire(wire: crate::wire::FileReadAtResponse<'de>) -> Self {
8840            Self { data: ::fidl_next::FromWire::from_wire(wire.data) }
8841        }
8842    }
8843
8844    impl<'de> ::fidl_next::FromWireRef<crate::wire::FileReadAtResponse<'de>> for FileReadAtResponse {
8845        #[inline]
8846        fn from_wire_ref(wire: &crate::wire::FileReadAtResponse<'de>) -> Self {
8847            Self { data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data) }
8848        }
8849    }
8850
8851    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
8852    pub struct FileWriteAtRequest {
8853        pub data: ::std::vec::Vec<u8>,
8854
8855        pub offset: u64,
8856    }
8857
8858    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
8859        for FileWriteAtRequest
8860    where
8861        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8862        ___E: ::fidl_next::Encoder,
8863    {
8864        #[inline]
8865        fn encode(
8866            self,
8867            encoder_: &mut ___E,
8868            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
8869            _: (),
8870        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8871            ::fidl_next::munge! {
8872                let crate::wire::FileWriteAtRequest {
8873                    data,
8874                    offset,
8875
8876                } = out_;
8877            }
8878
8879            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
8880
8881            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8882            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8883
8884            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
8885
8886            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8887
8888            Ok(())
8889        }
8890    }
8891
8892    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
8893        for &'a FileWriteAtRequest
8894    where
8895        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8896        ___E: ::fidl_next::Encoder,
8897    {
8898        #[inline]
8899        fn encode(
8900            self,
8901            encoder_: &mut ___E,
8902            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
8903            _: (),
8904        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8905            ::fidl_next::munge! {
8906                let crate::wire::FileWriteAtRequest {
8907                    data,
8908                    offset,
8909
8910                } = out_;
8911            }
8912
8913            ::fidl_next::Encode::encode(&self.data, encoder_, data, (8192, ()))?;
8914
8915            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(data.as_mut_ptr()) };
8916            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
8917
8918            ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
8919
8920            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
8921
8922            Ok(())
8923        }
8924    }
8925
8926    unsafe impl<___E>
8927        ::fidl_next::EncodeOption<
8928            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8929            ___E,
8930        > for FileWriteAtRequest
8931    where
8932        ___E: ::fidl_next::Encoder + ?Sized,
8933        FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
8934    {
8935        #[inline]
8936        fn encode_option(
8937            this: ::core::option::Option<Self>,
8938            encoder: &mut ___E,
8939            out: &mut ::core::mem::MaybeUninit<
8940                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8941            >,
8942            _: (),
8943        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8944            if let Some(inner) = this {
8945                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8946                ::fidl_next::wire::Box::encode_present(out);
8947            } else {
8948                ::fidl_next::wire::Box::encode_absent(out);
8949            }
8950
8951            Ok(())
8952        }
8953    }
8954
8955    unsafe impl<'a, ___E>
8956        ::fidl_next::EncodeOption<
8957            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8958            ___E,
8959        > for &'a FileWriteAtRequest
8960    where
8961        ___E: ::fidl_next::Encoder + ?Sized,
8962        &'a FileWriteAtRequest: ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>,
8963    {
8964        #[inline]
8965        fn encode_option(
8966            this: ::core::option::Option<Self>,
8967            encoder: &mut ___E,
8968            out: &mut ::core::mem::MaybeUninit<
8969                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtRequest<'static>>,
8970            >,
8971            _: (),
8972        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8973            if let Some(inner) = this {
8974                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
8975                ::fidl_next::wire::Box::encode_present(out);
8976            } else {
8977                ::fidl_next::wire::Box::encode_absent(out);
8978            }
8979
8980            Ok(())
8981        }
8982    }
8983
8984    impl<'de> ::fidl_next::FromWire<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
8985        #[inline]
8986        fn from_wire(wire: crate::wire::FileWriteAtRequest<'de>) -> Self {
8987            Self {
8988                data: ::fidl_next::FromWire::from_wire(wire.data),
8989
8990                offset: ::fidl_next::FromWire::from_wire(wire.offset),
8991            }
8992        }
8993    }
8994
8995    impl<'de> ::fidl_next::FromWireRef<crate::wire::FileWriteAtRequest<'de>> for FileWriteAtRequest {
8996        #[inline]
8997        fn from_wire_ref(wire: &crate::wire::FileWriteAtRequest<'de>) -> Self {
8998            Self {
8999                data: ::fidl_next::FromWireRef::from_wire_ref(&wire.data),
9000
9001                offset: ::fidl_next::FromWireRef::from_wire_ref(&wire.offset),
9002            }
9003        }
9004    }
9005
9006    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9007    #[repr(C)]
9008    pub struct FileWriteAtResponse {
9009        pub actual_count: u64,
9010    }
9011
9012    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
9013        for FileWriteAtResponse
9014    where
9015        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9016    {
9017        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9018            Self,
9019            crate::wire::FileWriteAtResponse,
9020        > = unsafe {
9021            ::fidl_next::CopyOptimization::enable_if(
9022            true
9023
9024                && <
9025                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9026                >::COPY_OPTIMIZATION.is_enabled()
9027
9028        )
9029        };
9030
9031        #[inline]
9032        fn encode(
9033            self,
9034            encoder_: &mut ___E,
9035            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
9036            _: (),
9037        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9038            ::fidl_next::munge! {
9039                let crate::wire::FileWriteAtResponse {
9040                    actual_count,
9041
9042                } = out_;
9043            }
9044
9045            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
9046
9047            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9048
9049            Ok(())
9050        }
9051    }
9052
9053    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
9054        for &'a FileWriteAtResponse
9055    where
9056        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9057    {
9058        #[inline]
9059        fn encode(
9060            self,
9061            encoder_: &mut ___E,
9062            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
9063            _: (),
9064        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9065            ::fidl_next::munge! {
9066                let crate::wire::FileWriteAtResponse {
9067                    actual_count,
9068
9069                } = out_;
9070            }
9071
9072            ::fidl_next::Encode::encode(&self.actual_count, encoder_, actual_count, ())?;
9073
9074            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(actual_count.as_mut_ptr()) };
9075
9076            Ok(())
9077        }
9078    }
9079
9080    unsafe impl<___E>
9081        ::fidl_next::EncodeOption<
9082            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9083            ___E,
9084        > for FileWriteAtResponse
9085    where
9086        ___E: ::fidl_next::Encoder + ?Sized,
9087        FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
9088    {
9089        #[inline]
9090        fn encode_option(
9091            this: ::core::option::Option<Self>,
9092            encoder: &mut ___E,
9093            out: &mut ::core::mem::MaybeUninit<
9094                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9095            >,
9096            _: (),
9097        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9098            if let Some(inner) = this {
9099                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9100                ::fidl_next::wire::Box::encode_present(out);
9101            } else {
9102                ::fidl_next::wire::Box::encode_absent(out);
9103            }
9104
9105            Ok(())
9106        }
9107    }
9108
9109    unsafe impl<'a, ___E>
9110        ::fidl_next::EncodeOption<
9111            ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9112            ___E,
9113        > for &'a FileWriteAtResponse
9114    where
9115        ___E: ::fidl_next::Encoder + ?Sized,
9116        &'a FileWriteAtResponse: ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>,
9117    {
9118        #[inline]
9119        fn encode_option(
9120            this: ::core::option::Option<Self>,
9121            encoder: &mut ___E,
9122            out: &mut ::core::mem::MaybeUninit<
9123                ::fidl_next::wire::Box<'static, crate::wire::FileWriteAtResponse>,
9124            >,
9125            _: (),
9126        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9127            if let Some(inner) = this {
9128                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9129                ::fidl_next::wire::Box::encode_present(out);
9130            } else {
9131                ::fidl_next::wire::Box::encode_absent(out);
9132            }
9133
9134            Ok(())
9135        }
9136    }
9137
9138    impl ::fidl_next::FromWire<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
9139        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9140            crate::wire::FileWriteAtResponse,
9141            Self,
9142        > = unsafe {
9143            ::fidl_next::CopyOptimization::enable_if(
9144                true
9145                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9146                        .is_enabled(),
9147            )
9148        };
9149
9150        #[inline]
9151        fn from_wire(wire: crate::wire::FileWriteAtResponse) -> Self {
9152            Self { actual_count: ::fidl_next::FromWire::from_wire(wire.actual_count) }
9153        }
9154    }
9155
9156    impl ::fidl_next::FromWireRef<crate::wire::FileWriteAtResponse> for FileWriteAtResponse {
9157        #[inline]
9158        fn from_wire_ref(wire: &crate::wire::FileWriteAtResponse) -> Self {
9159            Self { actual_count: ::fidl_next::FromWireRef::from_wire_ref(&wire.actual_count) }
9160        }
9161    }
9162
9163    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9164    #[repr(C)]
9165    pub struct FileResizeRequest {
9166        pub length: u64,
9167    }
9168
9169    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E> for FileResizeRequest
9170    where
9171        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9172    {
9173        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9174            Self,
9175            crate::wire::FileResizeRequest,
9176        > = unsafe {
9177            ::fidl_next::CopyOptimization::enable_if(
9178            true
9179
9180                && <
9181                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9182                >::COPY_OPTIMIZATION.is_enabled()
9183
9184        )
9185        };
9186
9187        #[inline]
9188        fn encode(
9189            self,
9190            encoder_: &mut ___E,
9191            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
9192            _: (),
9193        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9194            ::fidl_next::munge! {
9195                let crate::wire::FileResizeRequest {
9196                    length,
9197
9198                } = out_;
9199            }
9200
9201            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
9202
9203            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
9204
9205            Ok(())
9206        }
9207    }
9208
9209    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
9210        for &'a FileResizeRequest
9211    where
9212        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9213    {
9214        #[inline]
9215        fn encode(
9216            self,
9217            encoder_: &mut ___E,
9218            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
9219            _: (),
9220        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9221            ::fidl_next::munge! {
9222                let crate::wire::FileResizeRequest {
9223                    length,
9224
9225                } = out_;
9226            }
9227
9228            ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
9229
9230            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
9231
9232            Ok(())
9233        }
9234    }
9235
9236    unsafe impl<___E>
9237        ::fidl_next::EncodeOption<
9238            ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9239            ___E,
9240        > for FileResizeRequest
9241    where
9242        ___E: ::fidl_next::Encoder + ?Sized,
9243        FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
9244    {
9245        #[inline]
9246        fn encode_option(
9247            this: ::core::option::Option<Self>,
9248            encoder: &mut ___E,
9249            out: &mut ::core::mem::MaybeUninit<
9250                ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9251            >,
9252            _: (),
9253        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9254            if let Some(inner) = this {
9255                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9256                ::fidl_next::wire::Box::encode_present(out);
9257            } else {
9258                ::fidl_next::wire::Box::encode_absent(out);
9259            }
9260
9261            Ok(())
9262        }
9263    }
9264
9265    unsafe impl<'a, ___E>
9266        ::fidl_next::EncodeOption<
9267            ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9268            ___E,
9269        > for &'a FileResizeRequest
9270    where
9271        ___E: ::fidl_next::Encoder + ?Sized,
9272        &'a FileResizeRequest: ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>,
9273    {
9274        #[inline]
9275        fn encode_option(
9276            this: ::core::option::Option<Self>,
9277            encoder: &mut ___E,
9278            out: &mut ::core::mem::MaybeUninit<
9279                ::fidl_next::wire::Box<'static, crate::wire::FileResizeRequest>,
9280            >,
9281            _: (),
9282        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9283            if let Some(inner) = this {
9284                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9285                ::fidl_next::wire::Box::encode_present(out);
9286            } else {
9287                ::fidl_next::wire::Box::encode_absent(out);
9288            }
9289
9290            Ok(())
9291        }
9292    }
9293
9294    impl ::fidl_next::FromWire<crate::wire::FileResizeRequest> for FileResizeRequest {
9295        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9296            crate::wire::FileResizeRequest,
9297            Self,
9298        > = unsafe {
9299            ::fidl_next::CopyOptimization::enable_if(
9300                true
9301                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9302                        .is_enabled(),
9303            )
9304        };
9305
9306        #[inline]
9307        fn from_wire(wire: crate::wire::FileResizeRequest) -> Self {
9308            Self { length: ::fidl_next::FromWire::from_wire(wire.length) }
9309        }
9310    }
9311
9312    impl ::fidl_next::FromWireRef<crate::wire::FileResizeRequest> for FileResizeRequest {
9313        #[inline]
9314        fn from_wire_ref(wire: &crate::wire::FileResizeRequest) -> Self {
9315            Self { length: ::fidl_next::FromWireRef::from_wire_ref(&wire.length) }
9316        }
9317    }
9318
9319    pub type FileResizeResponse = ();
9320
9321    ::fidl_next::bitflags::bitflags! {
9322        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct VmoFlags: u32 {
9323            #[doc = " Requests that the VMO be readable.\n"]const READ = 1;
9324            #[doc = " Requests that the VMO be writable.\n"]const WRITE = 2;
9325            #[doc = " Request that the VMO be executable.\n"]const EXECUTE = 4;
9326            #[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;
9327            #[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;
9328
9329        }
9330    }
9331
9332    unsafe impl<___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for VmoFlags
9333    where
9334        ___E: ?Sized,
9335    {
9336        #[inline]
9337        fn encode(
9338            self,
9339            encoder: &mut ___E,
9340            out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
9341            _: (),
9342        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9343            ::fidl_next::Encode::encode(&self, encoder, out, ())
9344        }
9345    }
9346
9347    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::VmoFlags, ___E> for &'a VmoFlags
9348    where
9349        ___E: ?Sized,
9350    {
9351        #[inline]
9352        fn encode(
9353            self,
9354            _: &mut ___E,
9355            out: &mut ::core::mem::MaybeUninit<crate::wire::VmoFlags>,
9356            _: (),
9357        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9358            ::fidl_next::munge!(let crate::wire::VmoFlags { value } = out);
9359
9360            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
9361                return Err(::fidl_next::EncodeError::InvalidStrictBits);
9362            }
9363
9364            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
9365            Ok(())
9366        }
9367    }
9368
9369    impl ::core::convert::From<crate::wire::VmoFlags> for VmoFlags {
9370        fn from(wire: crate::wire::VmoFlags) -> Self {
9371            Self::from_bits_retain(u32::from(wire.value))
9372        }
9373    }
9374
9375    impl ::fidl_next::FromWire<crate::wire::VmoFlags> for VmoFlags {
9376        #[inline]
9377        fn from_wire(wire: crate::wire::VmoFlags) -> Self {
9378            Self::from(wire)
9379        }
9380    }
9381
9382    impl ::fidl_next::FromWireRef<crate::wire::VmoFlags> for VmoFlags {
9383        #[inline]
9384        fn from_wire_ref(wire: &crate::wire::VmoFlags) -> Self {
9385            Self::from(*wire)
9386        }
9387    }
9388
9389    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9390    #[repr(C)]
9391    pub struct FileGetBackingMemoryRequest {
9392        pub flags: crate::natural::VmoFlags,
9393    }
9394
9395    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
9396        for FileGetBackingMemoryRequest
9397    where
9398        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9399    {
9400        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9401            Self,
9402            crate::wire::FileGetBackingMemoryRequest,
9403        > = unsafe {
9404            ::fidl_next::CopyOptimization::enable_if(
9405                true && <crate::natural::VmoFlags as ::fidl_next::Encode<
9406                    crate::wire::VmoFlags,
9407                    ___E,
9408                >>::COPY_OPTIMIZATION
9409                    .is_enabled(),
9410            )
9411        };
9412
9413        #[inline]
9414        fn encode(
9415            self,
9416            encoder_: &mut ___E,
9417            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
9418            _: (),
9419        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9420            ::fidl_next::munge! {
9421                let crate::wire::FileGetBackingMemoryRequest {
9422                    flags,
9423
9424                } = out_;
9425            }
9426
9427            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
9428
9429            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
9430
9431            Ok(())
9432        }
9433    }
9434
9435    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
9436        for &'a FileGetBackingMemoryRequest
9437    where
9438        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9439    {
9440        #[inline]
9441        fn encode(
9442            self,
9443            encoder_: &mut ___E,
9444            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
9445            _: (),
9446        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9447            ::fidl_next::munge! {
9448                let crate::wire::FileGetBackingMemoryRequest {
9449                    flags,
9450
9451                } = out_;
9452            }
9453
9454            ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
9455
9456            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
9457
9458            Ok(())
9459        }
9460    }
9461
9462    unsafe impl<___E>
9463        ::fidl_next::EncodeOption<
9464            ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9465            ___E,
9466        > for FileGetBackingMemoryRequest
9467    where
9468        ___E: ::fidl_next::Encoder + ?Sized,
9469        FileGetBackingMemoryRequest:
9470            ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
9471    {
9472        #[inline]
9473        fn encode_option(
9474            this: ::core::option::Option<Self>,
9475            encoder: &mut ___E,
9476            out: &mut ::core::mem::MaybeUninit<
9477                ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9478            >,
9479            _: (),
9480        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9481            if let Some(inner) = this {
9482                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9483                ::fidl_next::wire::Box::encode_present(out);
9484            } else {
9485                ::fidl_next::wire::Box::encode_absent(out);
9486            }
9487
9488            Ok(())
9489        }
9490    }
9491
9492    unsafe impl<'a, ___E>
9493        ::fidl_next::EncodeOption<
9494            ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9495            ___E,
9496        > for &'a FileGetBackingMemoryRequest
9497    where
9498        ___E: ::fidl_next::Encoder + ?Sized,
9499        &'a FileGetBackingMemoryRequest:
9500            ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>,
9501    {
9502        #[inline]
9503        fn encode_option(
9504            this: ::core::option::Option<Self>,
9505            encoder: &mut ___E,
9506            out: &mut ::core::mem::MaybeUninit<
9507                ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryRequest>,
9508            >,
9509            _: (),
9510        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9511            if let Some(inner) = this {
9512                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9513                ::fidl_next::wire::Box::encode_present(out);
9514            } else {
9515                ::fidl_next::wire::Box::encode_absent(out);
9516            }
9517
9518            Ok(())
9519        }
9520    }
9521
9522    impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryRequest>
9523        for FileGetBackingMemoryRequest
9524    {
9525        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
9526            crate::wire::FileGetBackingMemoryRequest,
9527            Self,
9528        > = unsafe {
9529            ::fidl_next::CopyOptimization::enable_if(
9530                true && <crate::natural::VmoFlags as ::fidl_next::FromWire<
9531                    crate::wire::VmoFlags,
9532                >>::COPY_OPTIMIZATION
9533                    .is_enabled(),
9534            )
9535        };
9536
9537        #[inline]
9538        fn from_wire(wire: crate::wire::FileGetBackingMemoryRequest) -> Self {
9539            Self { flags: ::fidl_next::FromWire::from_wire(wire.flags) }
9540        }
9541    }
9542
9543    impl ::fidl_next::FromWireRef<crate::wire::FileGetBackingMemoryRequest>
9544        for FileGetBackingMemoryRequest
9545    {
9546        #[inline]
9547        fn from_wire_ref(wire: &crate::wire::FileGetBackingMemoryRequest) -> Self {
9548            Self { flags: ::fidl_next::FromWireRef::from_wire_ref(&wire.flags) }
9549        }
9550    }
9551
9552    pub type LinkableLinkIntoResponse = ();
9553
9554    pub type FileAllocateResponse = ();
9555
9556    pub type FileEnableVerityResponse = ();
9557
9558    ::fidl_next::bitflags::bitflags! {
9559        #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, )]pub struct FileSignal: u32 {
9560            #[doc = " Indicates the file is ready for reading.\n"]const READABLE = 16777216;
9561            #[doc = " Indicates the file is ready for writing.\n"]const WRITABLE = 33554432;
9562
9563        }
9564    }
9565
9566    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for FileSignal
9567    where
9568        ___E: ?Sized,
9569    {
9570        #[inline]
9571        fn encode(
9572            self,
9573            encoder: &mut ___E,
9574            out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
9575            _: (),
9576        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9577            ::fidl_next::Encode::encode(&self, encoder, out, ())
9578        }
9579    }
9580
9581    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FileSignal, ___E> for &'a FileSignal
9582    where
9583        ___E: ?Sized,
9584    {
9585        #[inline]
9586        fn encode(
9587            self,
9588            _: &mut ___E,
9589            out: &mut ::core::mem::MaybeUninit<crate::wire::FileSignal>,
9590            _: (),
9591        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9592            ::fidl_next::munge!(let crate::wire::FileSignal { value } = out);
9593
9594            if ::fidl_next::bitflags::Flags::contains_unknown_bits(self) {
9595                return Err(::fidl_next::EncodeError::InvalidStrictBits);
9596            }
9597
9598            let _ = value.write(::fidl_next::wire::Uint32::from(self.bits()));
9599            Ok(())
9600        }
9601    }
9602
9603    impl ::core::convert::From<crate::wire::FileSignal> for FileSignal {
9604        fn from(wire: crate::wire::FileSignal) -> Self {
9605            Self::from_bits_retain(u32::from(wire.value))
9606        }
9607    }
9608
9609    impl ::fidl_next::FromWire<crate::wire::FileSignal> for FileSignal {
9610        #[inline]
9611        fn from_wire(wire: crate::wire::FileSignal) -> Self {
9612            Self::from(wire)
9613        }
9614    }
9615
9616    impl ::fidl_next::FromWireRef<crate::wire::FileSignal> for FileSignal {
9617        #[inline]
9618        fn from_wire_ref(wire: &crate::wire::FileSignal) -> Self {
9619            Self::from(*wire)
9620        }
9621    }
9622
9623    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
9624    #[repr(C)]
9625    pub struct FilesystemInfo {
9626        pub total_bytes: u64,
9627
9628        pub used_bytes: u64,
9629
9630        pub total_nodes: u64,
9631
9632        pub used_nodes: u64,
9633
9634        pub free_shared_pool_bytes: u64,
9635
9636        pub fs_id: u64,
9637
9638        pub block_size: u32,
9639
9640        pub max_filename_size: u32,
9641
9642        pub fs_type: u32,
9643
9644        pub padding: u32,
9645
9646        pub name: [i8; 32],
9647    }
9648
9649    unsafe impl<___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for FilesystemInfo
9650    where
9651        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9652    {
9653        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FilesystemInfo> = unsafe {
9654            ::fidl_next::CopyOptimization::enable_if(
9655            true
9656
9657                && <
9658                    u64 as ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>
9659                >::COPY_OPTIMIZATION.is_enabled()
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                    u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___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                    [i8; 32] as ::fidl_next::Encode<[i8; 32], ___E>
9699                >::COPY_OPTIMIZATION.is_enabled()
9700
9701        )
9702        };
9703
9704        #[inline]
9705        fn encode(
9706            self,
9707            encoder_: &mut ___E,
9708            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
9709            _: (),
9710        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9711            ::fidl_next::munge! {
9712                let crate::wire::FilesystemInfo {
9713                    total_bytes,
9714                    used_bytes,
9715                    total_nodes,
9716                    used_nodes,
9717                    free_shared_pool_bytes,
9718                    fs_id,
9719                    block_size,
9720                    max_filename_size,
9721                    fs_type,
9722                    padding,
9723                    name,
9724
9725                } = out_;
9726            }
9727
9728            ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
9729
9730            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
9731
9732            ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
9733
9734            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
9735
9736            ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
9737
9738            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
9739
9740            ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
9741
9742            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
9743
9744            ::fidl_next::Encode::encode(
9745                self.free_shared_pool_bytes,
9746                encoder_,
9747                free_shared_pool_bytes,
9748                (),
9749            )?;
9750
9751            let mut _field =
9752                unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
9753
9754            ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
9755
9756            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
9757
9758            ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
9759
9760            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
9761
9762            ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
9763
9764            let mut _field =
9765                unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
9766
9767            ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
9768
9769            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
9770
9771            ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
9772
9773            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
9774
9775            ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
9776
9777            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
9778
9779            Ok(())
9780        }
9781    }
9782
9783    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E> for &'a FilesystemInfo
9784    where
9785        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
9786    {
9787        #[inline]
9788        fn encode(
9789            self,
9790            encoder_: &mut ___E,
9791            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
9792            _: (),
9793        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9794            ::fidl_next::munge! {
9795                let crate::wire::FilesystemInfo {
9796                    total_bytes,
9797                    used_bytes,
9798                    total_nodes,
9799                    used_nodes,
9800                    free_shared_pool_bytes,
9801                    fs_id,
9802                    block_size,
9803                    max_filename_size,
9804                    fs_type,
9805                    padding,
9806                    name,
9807
9808                } = out_;
9809            }
9810
9811            ::fidl_next::Encode::encode(&self.total_bytes, encoder_, total_bytes, ())?;
9812
9813            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_bytes.as_mut_ptr()) };
9814
9815            ::fidl_next::Encode::encode(&self.used_bytes, encoder_, used_bytes, ())?;
9816
9817            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_bytes.as_mut_ptr()) };
9818
9819            ::fidl_next::Encode::encode(&self.total_nodes, encoder_, total_nodes, ())?;
9820
9821            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(total_nodes.as_mut_ptr()) };
9822
9823            ::fidl_next::Encode::encode(&self.used_nodes, encoder_, used_nodes, ())?;
9824
9825            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(used_nodes.as_mut_ptr()) };
9826
9827            ::fidl_next::Encode::encode(
9828                &self.free_shared_pool_bytes,
9829                encoder_,
9830                free_shared_pool_bytes,
9831                (),
9832            )?;
9833
9834            let mut _field =
9835                unsafe { ::fidl_next::Slot::new_unchecked(free_shared_pool_bytes.as_mut_ptr()) };
9836
9837            ::fidl_next::Encode::encode(&self.fs_id, encoder_, fs_id, ())?;
9838
9839            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_id.as_mut_ptr()) };
9840
9841            ::fidl_next::Encode::encode(&self.block_size, encoder_, block_size, ())?;
9842
9843            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(block_size.as_mut_ptr()) };
9844
9845            ::fidl_next::Encode::encode(&self.max_filename_size, encoder_, max_filename_size, ())?;
9846
9847            let mut _field =
9848                unsafe { ::fidl_next::Slot::new_unchecked(max_filename_size.as_mut_ptr()) };
9849
9850            ::fidl_next::Encode::encode(&self.fs_type, encoder_, fs_type, ())?;
9851
9852            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(fs_type.as_mut_ptr()) };
9853
9854            ::fidl_next::Encode::encode(&self.padding, encoder_, padding, ())?;
9855
9856            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(padding.as_mut_ptr()) };
9857
9858            ::fidl_next::Encode::encode(&self.name, encoder_, name, ())?;
9859
9860            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
9861
9862            Ok(())
9863        }
9864    }
9865
9866    unsafe impl<___E>
9867        ::fidl_next::EncodeOption<
9868            ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9869            ___E,
9870        > for FilesystemInfo
9871    where
9872        ___E: ::fidl_next::Encoder + ?Sized,
9873        FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
9874    {
9875        #[inline]
9876        fn encode_option(
9877            this: ::core::option::Option<Self>,
9878            encoder: &mut ___E,
9879            out: &mut ::core::mem::MaybeUninit<
9880                ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9881            >,
9882            _: (),
9883        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9884            if let Some(inner) = this {
9885                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9886                ::fidl_next::wire::Box::encode_present(out);
9887            } else {
9888                ::fidl_next::wire::Box::encode_absent(out);
9889            }
9890
9891            Ok(())
9892        }
9893    }
9894
9895    unsafe impl<'a, ___E>
9896        ::fidl_next::EncodeOption<
9897            ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9898            ___E,
9899        > for &'a FilesystemInfo
9900    where
9901        ___E: ::fidl_next::Encoder + ?Sized,
9902        &'a FilesystemInfo: ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>,
9903    {
9904        #[inline]
9905        fn encode_option(
9906            this: ::core::option::Option<Self>,
9907            encoder: &mut ___E,
9908            out: &mut ::core::mem::MaybeUninit<
9909                ::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>,
9910            >,
9911            _: (),
9912        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
9913            if let Some(inner) = this {
9914                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
9915                ::fidl_next::wire::Box::encode_present(out);
9916            } else {
9917                ::fidl_next::wire::Box::encode_absent(out);
9918            }
9919
9920            Ok(())
9921        }
9922    }
9923
9924    impl ::fidl_next::FromWire<crate::wire::FilesystemInfo> for FilesystemInfo {
9925        const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FilesystemInfo, Self> = unsafe {
9926            ::fidl_next::CopyOptimization::enable_if(
9927                true
9928                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9929                        .is_enabled()
9930                    && <u64 as ::fidl_next::FromWire<::fidl_next::wire::Uint64>>::COPY_OPTIMIZATION
9931                        .is_enabled()
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                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
9941                        .is_enabled()
9942                    && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::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                    && <[i8; 32] as ::fidl_next::FromWire<[i8; 32]>>::COPY_OPTIMIZATION
9949                        .is_enabled(),
9950            )
9951        };
9952
9953        #[inline]
9954        fn from_wire(wire: crate::wire::FilesystemInfo) -> Self {
9955            Self {
9956                total_bytes: ::fidl_next::FromWire::from_wire(wire.total_bytes),
9957
9958                used_bytes: ::fidl_next::FromWire::from_wire(wire.used_bytes),
9959
9960                total_nodes: ::fidl_next::FromWire::from_wire(wire.total_nodes),
9961
9962                used_nodes: ::fidl_next::FromWire::from_wire(wire.used_nodes),
9963
9964                free_shared_pool_bytes: ::fidl_next::FromWire::from_wire(
9965                    wire.free_shared_pool_bytes,
9966                ),
9967
9968                fs_id: ::fidl_next::FromWire::from_wire(wire.fs_id),
9969
9970                block_size: ::fidl_next::FromWire::from_wire(wire.block_size),
9971
9972                max_filename_size: ::fidl_next::FromWire::from_wire(wire.max_filename_size),
9973
9974                fs_type: ::fidl_next::FromWire::from_wire(wire.fs_type),
9975
9976                padding: ::fidl_next::FromWire::from_wire(wire.padding),
9977
9978                name: ::fidl_next::FromWire::from_wire(wire.name),
9979            }
9980        }
9981    }
9982
9983    impl ::fidl_next::FromWireRef<crate::wire::FilesystemInfo> for FilesystemInfo {
9984        #[inline]
9985        fn from_wire_ref(wire: &crate::wire::FilesystemInfo) -> Self {
9986            Self {
9987                total_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_bytes),
9988
9989                used_bytes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_bytes),
9990
9991                total_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.total_nodes),
9992
9993                used_nodes: ::fidl_next::FromWireRef::from_wire_ref(&wire.used_nodes),
9994
9995                free_shared_pool_bytes: ::fidl_next::FromWireRef::from_wire_ref(
9996                    &wire.free_shared_pool_bytes,
9997                ),
9998
9999                fs_id: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_id),
10000
10001                block_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.block_size),
10002
10003                max_filename_size: ::fidl_next::FromWireRef::from_wire_ref(&wire.max_filename_size),
10004
10005                fs_type: ::fidl_next::FromWireRef::from_wire_ref(&wire.fs_type),
10006
10007                padding: ::fidl_next::FromWireRef::from_wire_ref(&wire.padding),
10008
10009                name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name),
10010            }
10011        }
10012    }
10013
10014    pub type Service = ();
10015
10016    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10017    pub struct SymlinkObject {
10018        pub target: ::std::vec::Vec<u8>,
10019    }
10020
10021    unsafe impl<___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E> for SymlinkObject
10022    where
10023        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10024        ___E: ::fidl_next::Encoder,
10025    {
10026        #[inline]
10027        fn encode(
10028            self,
10029            encoder_: &mut ___E,
10030            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
10031            _: (),
10032        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10033            ::fidl_next::munge! {
10034                let crate::wire::SymlinkObject {
10035                    target,
10036
10037                } = out_;
10038            }
10039
10040            ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
10041
10042            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
10043            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
10044
10045            Ok(())
10046        }
10047    }
10048
10049    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
10050        for &'a SymlinkObject
10051    where
10052        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
10053        ___E: ::fidl_next::Encoder,
10054    {
10055        #[inline]
10056        fn encode(
10057            self,
10058            encoder_: &mut ___E,
10059            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
10060            _: (),
10061        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10062            ::fidl_next::munge! {
10063                let crate::wire::SymlinkObject {
10064                    target,
10065
10066                } = out_;
10067            }
10068
10069            ::fidl_next::Encode::encode(&self.target, encoder_, target, (4095, ()))?;
10070
10071            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
10072            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
10073
10074            Ok(())
10075        }
10076    }
10077
10078    unsafe impl<___E>
10079        ::fidl_next::EncodeOption<
10080            ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10081            ___E,
10082        > for SymlinkObject
10083    where
10084        ___E: ::fidl_next::Encoder + ?Sized,
10085        SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
10086    {
10087        #[inline]
10088        fn encode_option(
10089            this: ::core::option::Option<Self>,
10090            encoder: &mut ___E,
10091            out: &mut ::core::mem::MaybeUninit<
10092                ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10093            >,
10094            _: (),
10095        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10096            if let Some(inner) = this {
10097                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10098                ::fidl_next::wire::Box::encode_present(out);
10099            } else {
10100                ::fidl_next::wire::Box::encode_absent(out);
10101            }
10102
10103            Ok(())
10104        }
10105    }
10106
10107    unsafe impl<'a, ___E>
10108        ::fidl_next::EncodeOption<
10109            ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10110            ___E,
10111        > for &'a SymlinkObject
10112    where
10113        ___E: ::fidl_next::Encoder + ?Sized,
10114        &'a SymlinkObject: ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>,
10115    {
10116        #[inline]
10117        fn encode_option(
10118            this: ::core::option::Option<Self>,
10119            encoder: &mut ___E,
10120            out: &mut ::core::mem::MaybeUninit<
10121                ::fidl_next::wire::Box<'static, crate::wire::SymlinkObject<'static>>,
10122            >,
10123            _: (),
10124        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10125            if let Some(inner) = this {
10126                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
10127                ::fidl_next::wire::Box::encode_present(out);
10128            } else {
10129                ::fidl_next::wire::Box::encode_absent(out);
10130            }
10131
10132            Ok(())
10133        }
10134    }
10135
10136    impl<'de> ::fidl_next::FromWire<crate::wire::SymlinkObject<'de>> for SymlinkObject {
10137        #[inline]
10138        fn from_wire(wire: crate::wire::SymlinkObject<'de>) -> Self {
10139            Self { target: ::fidl_next::FromWire::from_wire(wire.target) }
10140        }
10141    }
10142
10143    impl<'de> ::fidl_next::FromWireRef<crate::wire::SymlinkObject<'de>> for SymlinkObject {
10144        #[inline]
10145        fn from_wire_ref(wire: &crate::wire::SymlinkObject<'de>) -> Self {
10146            Self { target: ::fidl_next::FromWireRef::from_wire_ref(&wire.target) }
10147        }
10148    }
10149
10150    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10151    #[repr(u8)]
10152    pub enum WatchEvent {
10153        Deleted = 0,
10154        Added = 1,
10155        Removed = 2,
10156        Existing = 3,
10157        Idle = 4,
10158    }
10159    impl ::core::convert::TryFrom<u8> for WatchEvent {
10160        type Error = ::fidl_next::UnknownStrictEnumMemberError;
10161        fn try_from(
10162            value: u8,
10163        ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
10164            match value {
10165                0 => Ok(Self::Deleted),
10166                1 => Ok(Self::Added),
10167                2 => Ok(Self::Removed),
10168                3 => Ok(Self::Existing),
10169                4 => Ok(Self::Idle),
10170
10171                _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
10172            }
10173        }
10174    }
10175
10176    unsafe impl<___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for WatchEvent
10177    where
10178        ___E: ?Sized,
10179    {
10180        #[inline]
10181        fn encode(
10182            self,
10183            encoder: &mut ___E,
10184            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
10185            _: (),
10186        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10187            ::fidl_next::Encode::encode(&self, encoder, out, ())
10188        }
10189    }
10190
10191    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::WatchEvent, ___E> for &'a WatchEvent
10192    where
10193        ___E: ?Sized,
10194    {
10195        #[inline]
10196        fn encode(
10197            self,
10198            encoder: &mut ___E,
10199            out: &mut ::core::mem::MaybeUninit<crate::wire::WatchEvent>,
10200            _: (),
10201        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
10202            ::fidl_next::munge!(let crate::wire::WatchEvent { value } = out);
10203            let _ = value.write(u8::from(match *self {
10204                WatchEvent::Deleted => 0,
10205
10206                WatchEvent::Added => 1,
10207
10208                WatchEvent::Removed => 2,
10209
10210                WatchEvent::Existing => 3,
10211
10212                WatchEvent::Idle => 4,
10213            }));
10214
10215            Ok(())
10216        }
10217    }
10218
10219    impl ::core::convert::From<crate::wire::WatchEvent> for WatchEvent {
10220        fn from(wire: crate::wire::WatchEvent) -> Self {
10221            match u8::from(wire.value) {
10222                0 => Self::Deleted,
10223
10224                1 => Self::Added,
10225
10226                2 => Self::Removed,
10227
10228                3 => Self::Existing,
10229
10230                4 => Self::Idle,
10231
10232                _ => unsafe { ::core::hint::unreachable_unchecked() },
10233            }
10234        }
10235    }
10236
10237    impl ::fidl_next::FromWire<crate::wire::WatchEvent> for WatchEvent {
10238        #[inline]
10239        fn from_wire(wire: crate::wire::WatchEvent) -> Self {
10240            Self::from(wire)
10241        }
10242    }
10243
10244    impl ::fidl_next::FromWireRef<crate::wire::WatchEvent> for WatchEvent {
10245        #[inline]
10246        fn from_wire_ref(wire: &crate::wire::WatchEvent) -> Self {
10247            Self::from(*wire)
10248        }
10249    }
10250}
10251
10252pub mod wire {
10253
10254    /// The wire type corresponding to [`Operations`](crate::natural::Operations).
10255    #[derive(Clone, Copy, Debug)]
10256    #[repr(transparent)]
10257    pub struct Operations {
10258        pub(crate) value: ::fidl_next::wire::Uint64,
10259    }
10260
10261    impl ::fidl_next::Constrained for Operations {
10262        type Constraint = ();
10263
10264        fn validate(
10265            _: ::fidl_next::Slot<'_, Self>,
10266            _: Self::Constraint,
10267        ) -> Result<(), ::fidl_next::ValidationError> {
10268            Ok(())
10269        }
10270    }
10271
10272    unsafe impl ::fidl_next::Wire for Operations {
10273        type Narrowed<'de> = Self;
10274
10275        #[inline]
10276        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10277            // Wire bits have no padding
10278        }
10279    }
10280
10281    unsafe impl<___D> ::fidl_next::Decode<___D> for Operations
10282    where
10283        ___D: ?Sized,
10284    {
10285        fn decode(
10286            slot: ::fidl_next::Slot<'_, Self>,
10287            _: &mut ___D,
10288            _: (),
10289        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10290            Ok(())
10291        }
10292    }
10293
10294    impl ::core::convert::From<crate::natural::Operations> for Operations {
10295        fn from(natural: crate::natural::Operations) -> Self {
10296            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
10297        }
10298    }
10299
10300    impl ::fidl_next::IntoNatural for Operations {
10301        type Natural = crate::natural::Operations;
10302    }
10303
10304    /// The wire type corresponding to [`Abilities`](crate::natural::Abilities).
10305    pub type Abilities = crate::wire::Operations;
10306
10307    /// The wire type corresponding to [`SeekOrigin`].
10308    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10309    #[repr(transparent)]
10310    pub struct SeekOrigin {
10311        pub(crate) value: ::fidl_next::wire::Uint32,
10312    }
10313
10314    impl ::fidl_next::Constrained for SeekOrigin {
10315        type Constraint = ();
10316
10317        fn validate(
10318            _: ::fidl_next::Slot<'_, Self>,
10319            _: Self::Constraint,
10320        ) -> Result<(), ::fidl_next::ValidationError> {
10321            Ok(())
10322        }
10323    }
10324
10325    unsafe impl ::fidl_next::Wire for SeekOrigin {
10326        type Narrowed<'de> = Self;
10327
10328        #[inline]
10329        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10330            // Wire enums have no padding
10331        }
10332    }
10333
10334    impl SeekOrigin {
10335        pub const START: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(0) };
10336
10337        pub const CURRENT: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(1) };
10338
10339        pub const END: SeekOrigin = SeekOrigin { value: ::fidl_next::wire::Uint32(2) };
10340    }
10341
10342    unsafe impl<___D> ::fidl_next::Decode<___D> for SeekOrigin
10343    where
10344        ___D: ?Sized,
10345    {
10346        fn decode(
10347            slot: ::fidl_next::Slot<'_, Self>,
10348            _: &mut ___D,
10349            _: (),
10350        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10351            ::fidl_next::munge!(let Self { value } = slot);
10352
10353            match u32::from(*value) {
10354                0 | 1 | 2 => (),
10355                unknown => {
10356                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
10357                }
10358            }
10359
10360            Ok(())
10361        }
10362    }
10363
10364    impl ::core::convert::From<crate::natural::SeekOrigin> for SeekOrigin {
10365        fn from(natural: crate::natural::SeekOrigin) -> Self {
10366            match natural {
10367                crate::natural::SeekOrigin::Start => SeekOrigin::START,
10368
10369                crate::natural::SeekOrigin::Current => SeekOrigin::CURRENT,
10370
10371                crate::natural::SeekOrigin::End => SeekOrigin::END,
10372            }
10373        }
10374    }
10375
10376    impl ::fidl_next::IntoNatural for SeekOrigin {
10377        type Natural = crate::natural::SeekOrigin;
10378    }
10379
10380    /// The wire type corresponding to [`AdvisoryLockRange`].
10381    #[derive(Clone, Debug)]
10382    #[repr(C)]
10383    pub struct AdvisoryLockRange {
10384        pub origin: crate::wire::SeekOrigin,
10385
10386        pub offset: ::fidl_next::wire::Int64,
10387
10388        pub length: ::fidl_next::wire::Int64,
10389    }
10390
10391    static_assertions::const_assert_eq!(std::mem::size_of::<AdvisoryLockRange>(), 24);
10392    static_assertions::const_assert_eq!(std::mem::align_of::<AdvisoryLockRange>(), 8);
10393
10394    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, origin), 0);
10395
10396    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, offset), 8);
10397
10398    static_assertions::const_assert_eq!(std::mem::offset_of!(AdvisoryLockRange, length), 16);
10399
10400    impl ::fidl_next::Constrained for AdvisoryLockRange {
10401        type Constraint = ();
10402
10403        fn validate(
10404            _: ::fidl_next::Slot<'_, Self>,
10405            _: Self::Constraint,
10406        ) -> Result<(), ::fidl_next::ValidationError> {
10407            Ok(())
10408        }
10409    }
10410
10411    unsafe impl ::fidl_next::Wire for AdvisoryLockRange {
10412        type Narrowed<'de> = AdvisoryLockRange;
10413
10414        #[inline]
10415        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10416            ::fidl_next::munge! {
10417                let Self {
10418                    origin,
10419                    offset,
10420                    length,
10421
10422                } = &mut *out_;
10423            }
10424
10425            ::fidl_next::Wire::zero_padding(origin);
10426
10427            ::fidl_next::Wire::zero_padding(offset);
10428
10429            ::fidl_next::Wire::zero_padding(length);
10430
10431            unsafe {
10432                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
10433            }
10434        }
10435    }
10436
10437    unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockRange
10438    where
10439        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10440    {
10441        fn decode(
10442            slot_: ::fidl_next::Slot<'_, Self>,
10443            decoder_: &mut ___D,
10444            _: (),
10445        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10446            if slot_.as_bytes()[4..8] != [0u8; 4] {
10447                return Err(::fidl_next::DecodeError::InvalidPadding);
10448            }
10449
10450            ::fidl_next::munge! {
10451                let Self {
10452                    mut origin,
10453                    mut offset,
10454                    mut length,
10455
10456                } = slot_;
10457            }
10458
10459            let _field = origin.as_mut();
10460
10461            ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
10462
10463            let _field = offset.as_mut();
10464
10465            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
10466
10467            let _field = length.as_mut();
10468
10469            ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
10470
10471            Ok(())
10472        }
10473    }
10474
10475    impl ::fidl_next::IntoNatural for AdvisoryLockRange {
10476        type Natural = crate::natural::AdvisoryLockRange;
10477    }
10478
10479    /// The wire type corresponding to [`AdvisoryLockType`].
10480    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
10481    #[repr(transparent)]
10482    pub struct AdvisoryLockType {
10483        pub(crate) value: ::fidl_next::wire::Uint32,
10484    }
10485
10486    impl ::fidl_next::Constrained for AdvisoryLockType {
10487        type Constraint = ();
10488
10489        fn validate(
10490            _: ::fidl_next::Slot<'_, Self>,
10491            _: Self::Constraint,
10492        ) -> Result<(), ::fidl_next::ValidationError> {
10493            Ok(())
10494        }
10495    }
10496
10497    unsafe impl ::fidl_next::Wire for AdvisoryLockType {
10498        type Narrowed<'de> = Self;
10499
10500        #[inline]
10501        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10502            // Wire enums have no padding
10503        }
10504    }
10505
10506    impl AdvisoryLockType {
10507        pub const READ: AdvisoryLockType = AdvisoryLockType { value: ::fidl_next::wire::Uint32(1) };
10508
10509        pub const WRITE: AdvisoryLockType =
10510            AdvisoryLockType { value: ::fidl_next::wire::Uint32(2) };
10511
10512        pub const UNLOCK: AdvisoryLockType =
10513            AdvisoryLockType { value: ::fidl_next::wire::Uint32(3) };
10514    }
10515
10516    unsafe impl<___D> ::fidl_next::Decode<___D> for AdvisoryLockType
10517    where
10518        ___D: ?Sized,
10519    {
10520        fn decode(
10521            slot: ::fidl_next::Slot<'_, Self>,
10522            _: &mut ___D,
10523            _: (),
10524        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10525            ::fidl_next::munge!(let Self { value } = slot);
10526
10527            match u32::from(*value) {
10528                1 | 2 | 3 => (),
10529                unknown => {
10530                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
10531                }
10532            }
10533
10534            Ok(())
10535        }
10536    }
10537
10538    impl ::core::convert::From<crate::natural::AdvisoryLockType> for AdvisoryLockType {
10539        fn from(natural: crate::natural::AdvisoryLockType) -> Self {
10540            match natural {
10541                crate::natural::AdvisoryLockType::Read => AdvisoryLockType::READ,
10542
10543                crate::natural::AdvisoryLockType::Write => AdvisoryLockType::WRITE,
10544
10545                crate::natural::AdvisoryLockType::Unlock => AdvisoryLockType::UNLOCK,
10546            }
10547        }
10548    }
10549
10550    impl ::fidl_next::IntoNatural for AdvisoryLockType {
10551        type Natural = crate::natural::AdvisoryLockType;
10552    }
10553
10554    /// The wire type corresponding to [`AdvisoryLockRequest`].
10555    #[repr(C)]
10556    pub struct AdvisoryLockRequest<'de> {
10557        pub(crate) table: ::fidl_next::wire::Table<'de>,
10558    }
10559
10560    impl<'de> Drop for AdvisoryLockRequest<'de> {
10561        fn drop(&mut self) {
10562            let _ = self.table.get(1).map(|envelope| unsafe {
10563                envelope.read_unchecked::<crate::wire::AdvisoryLockType>()
10564            });
10565
10566            let _ = self.table.get(2).map(|envelope| unsafe {
10567                envelope.read_unchecked::<crate::wire::AdvisoryLockRange>()
10568            });
10569
10570            let _ = self.table.get(3).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
10571        }
10572    }
10573
10574    impl ::fidl_next::Constrained for AdvisoryLockRequest<'_> {
10575        type Constraint = ();
10576
10577        fn validate(
10578            _: ::fidl_next::Slot<'_, Self>,
10579            _: Self::Constraint,
10580        ) -> Result<(), ::fidl_next::ValidationError> {
10581            Ok(())
10582        }
10583    }
10584
10585    unsafe impl ::fidl_next::Wire for AdvisoryLockRequest<'static> {
10586        type Narrowed<'de> = AdvisoryLockRequest<'de>;
10587
10588        #[inline]
10589        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
10590            ::fidl_next::munge!(let Self { table } = out);
10591            ::fidl_next::wire::Table::zero_padding(table);
10592        }
10593    }
10594
10595    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockRequest<'de>
10596    where
10597        ___D: ::fidl_next::Decoder<'de> + ?Sized,
10598    {
10599        fn decode(
10600            slot: ::fidl_next::Slot<'_, Self>,
10601            decoder: &mut ___D,
10602            _: (),
10603        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10604            ::fidl_next::munge!(let Self { table } = slot);
10605
10606            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
10607                match ordinal {
10608                    0 => unsafe { ::core::hint::unreachable_unchecked() },
10609
10610                    1 => {
10611                        ::fidl_next::wire::Envelope::decode_as::<
10612                            ___D,
10613                            crate::wire::AdvisoryLockType,
10614                        >(slot.as_mut(), decoder, ())?;
10615
10616                        Ok(())
10617                    }
10618
10619                    2 => {
10620                        ::fidl_next::wire::Envelope::decode_as::<
10621                            ___D,
10622                            crate::wire::AdvisoryLockRange,
10623                        >(slot.as_mut(), decoder, ())?;
10624
10625                        Ok(())
10626                    }
10627
10628                    3 => {
10629                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
10630                            slot.as_mut(),
10631                            decoder,
10632                            (),
10633                        )?;
10634
10635                        Ok(())
10636                    }
10637
10638                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
10639                }
10640            })
10641        }
10642    }
10643
10644    impl<'de> AdvisoryLockRequest<'de> {
10645        pub fn type_(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockType> {
10646            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
10647        }
10648
10649        pub fn take_type_(&mut self) -> ::core::option::Option<crate::wire::AdvisoryLockType> {
10650            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
10651        }
10652
10653        pub fn range(&self) -> ::core::option::Option<&crate::wire::AdvisoryLockRange> {
10654            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
10655        }
10656
10657        pub fn take_range(&mut self) -> ::core::option::Option<crate::wire::AdvisoryLockRange> {
10658            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
10659        }
10660
10661        pub fn wait(&self) -> ::core::option::Option<&bool> {
10662            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
10663        }
10664
10665        pub fn take_wait(&mut self) -> ::core::option::Option<bool> {
10666            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
10667        }
10668    }
10669
10670    impl<'de> ::core::fmt::Debug for AdvisoryLockRequest<'de> {
10671        fn fmt(
10672            &self,
10673            f: &mut ::core::fmt::Formatter<'_>,
10674        ) -> ::core::result::Result<(), ::core::fmt::Error> {
10675            f.debug_struct("AdvisoryLockRequest")
10676                .field("type_", &self.type_())
10677                .field("range", &self.range())
10678                .field("wait", &self.wait())
10679                .finish()
10680        }
10681    }
10682
10683    impl<'de> ::fidl_next::IntoNatural for AdvisoryLockRequest<'de> {
10684        type Natural = crate::natural::AdvisoryLockRequest;
10685    }
10686
10687    /// The wire type corresponding to [`AdvisoryLockingAdvisoryLockRequest`].
10688    #[derive(Debug)]
10689    #[repr(C)]
10690    pub struct AdvisoryLockingAdvisoryLockRequest<'de> {
10691        pub request: crate::wire::AdvisoryLockRequest<'de>,
10692    }
10693
10694    static_assertions::const_assert_eq!(
10695        std::mem::size_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
10696        16
10697    );
10698    static_assertions::const_assert_eq!(
10699        std::mem::align_of::<AdvisoryLockingAdvisoryLockRequest<'_>>(),
10700        8
10701    );
10702
10703    static_assertions::const_assert_eq!(
10704        std::mem::offset_of!(AdvisoryLockingAdvisoryLockRequest<'_>, request),
10705        0
10706    );
10707
10708    impl ::fidl_next::Constrained for AdvisoryLockingAdvisoryLockRequest<'_> {
10709        type Constraint = ();
10710
10711        fn validate(
10712            _: ::fidl_next::Slot<'_, Self>,
10713            _: Self::Constraint,
10714        ) -> Result<(), ::fidl_next::ValidationError> {
10715            Ok(())
10716        }
10717    }
10718
10719    unsafe impl ::fidl_next::Wire for AdvisoryLockingAdvisoryLockRequest<'static> {
10720        type Narrowed<'de> = AdvisoryLockingAdvisoryLockRequest<'de>;
10721
10722        #[inline]
10723        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10724            ::fidl_next::munge! {
10725                let Self {
10726                    request,
10727
10728                } = &mut *out_;
10729            }
10730
10731            ::fidl_next::Wire::zero_padding(request);
10732        }
10733    }
10734
10735    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for AdvisoryLockingAdvisoryLockRequest<'de>
10736    where
10737        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10738        ___D: ::fidl_next::Decoder<'de>,
10739    {
10740        fn decode(
10741            slot_: ::fidl_next::Slot<'_, Self>,
10742            decoder_: &mut ___D,
10743            _: (),
10744        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10745            ::fidl_next::munge! {
10746                let Self {
10747                    mut request,
10748
10749                } = slot_;
10750            }
10751
10752            let _field = request.as_mut();
10753
10754            ::fidl_next::Decode::decode(request.as_mut(), decoder_, ())?;
10755
10756            Ok(())
10757        }
10758    }
10759
10760    impl<'de> ::fidl_next::IntoNatural for AdvisoryLockingAdvisoryLockRequest<'de> {
10761        type Natural = crate::natural::AdvisoryLockingAdvisoryLockRequest;
10762    }
10763
10764    /// The wire type corresponding to [`AdvisoryLockingAdvisoryLockResponse`].
10765    pub type AdvisoryLockingAdvisoryLockResponse = ::fidl_next::wire::Unit;
10766
10767    /// The wire type corresponding to [`AllocateMode`](crate::natural::AllocateMode).
10768    #[derive(Clone, Copy, Debug)]
10769    #[repr(transparent)]
10770    pub struct AllocateMode {
10771        pub(crate) value: ::fidl_next::wire::Uint32,
10772    }
10773
10774    impl ::fidl_next::Constrained for AllocateMode {
10775        type Constraint = ();
10776
10777        fn validate(
10778            _: ::fidl_next::Slot<'_, Self>,
10779            _: Self::Constraint,
10780        ) -> Result<(), ::fidl_next::ValidationError> {
10781            Ok(())
10782        }
10783    }
10784
10785    unsafe impl ::fidl_next::Wire for AllocateMode {
10786        type Narrowed<'de> = Self;
10787
10788        #[inline]
10789        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10790            // Wire bits have no padding
10791        }
10792    }
10793
10794    unsafe impl<___D> ::fidl_next::Decode<___D> for AllocateMode
10795    where
10796        ___D: ?Sized,
10797    {
10798        fn decode(
10799            slot: ::fidl_next::Slot<'_, Self>,
10800            _: &mut ___D,
10801            _: (),
10802        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10803            Ok(())
10804        }
10805    }
10806
10807    impl ::core::convert::From<crate::natural::AllocateMode> for AllocateMode {
10808        fn from(natural: crate::natural::AllocateMode) -> Self {
10809            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
10810        }
10811    }
10812
10813    impl ::fidl_next::IntoNatural for AllocateMode {
10814        type Natural = crate::natural::AllocateMode;
10815    }
10816
10817    /// The wire type corresponding to [`Rights`](crate::natural::Rights).
10818    pub type Rights = crate::wire::Operations;
10819
10820    /// The wire type corresponding to [`Id`](crate::natural::Id).
10821    pub type Id = ::fidl_next::wire::Uint64;
10822
10823    /// The wire type corresponding to [`OpenFlags`](crate::natural::OpenFlags).
10824    #[derive(Clone, Copy, Debug)]
10825    #[repr(transparent)]
10826    pub struct OpenFlags {
10827        pub(crate) value: ::fidl_next::wire::Uint32,
10828    }
10829
10830    impl ::fidl_next::Constrained for OpenFlags {
10831        type Constraint = ();
10832
10833        fn validate(
10834            _: ::fidl_next::Slot<'_, Self>,
10835            _: Self::Constraint,
10836        ) -> Result<(), ::fidl_next::ValidationError> {
10837            Ok(())
10838        }
10839    }
10840
10841    unsafe impl ::fidl_next::Wire for OpenFlags {
10842        type Narrowed<'de> = Self;
10843
10844        #[inline]
10845        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
10846            // Wire bits have no padding
10847        }
10848    }
10849
10850    unsafe impl<___D> ::fidl_next::Decode<___D> for OpenFlags
10851    where
10852        ___D: ?Sized,
10853    {
10854        fn decode(
10855            slot: ::fidl_next::Slot<'_, Self>,
10856            _: &mut ___D,
10857            _: (),
10858        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10859            ::fidl_next::munge!(let Self { value } = slot);
10860            let set = u32::from(*value);
10861            if set & !crate::natural::OpenFlags::all().bits() != 0 {
10862                return Err(::fidl_next::DecodeError::InvalidBits {
10863                    expected: crate::natural::OpenFlags::all().bits() as usize,
10864                    actual: set as usize,
10865                });
10866            }
10867
10868            Ok(())
10869        }
10870    }
10871
10872    impl ::core::convert::From<crate::natural::OpenFlags> for OpenFlags {
10873        fn from(natural: crate::natural::OpenFlags) -> Self {
10874            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
10875        }
10876    }
10877
10878    impl ::fidl_next::IntoNatural for OpenFlags {
10879        type Natural = crate::natural::OpenFlags;
10880    }
10881
10882    /// The wire type corresponding to [`NodeAttributes`].
10883    #[derive(Clone, Debug)]
10884    #[repr(C)]
10885    pub struct NodeAttributes {
10886        pub mode: ::fidl_next::wire::Uint32,
10887
10888        pub id: ::fidl_next::wire::Uint64,
10889
10890        pub content_size: ::fidl_next::wire::Uint64,
10891
10892        pub storage_size: ::fidl_next::wire::Uint64,
10893
10894        pub link_count: ::fidl_next::wire::Uint64,
10895
10896        pub creation_time: ::fidl_next::wire::Uint64,
10897
10898        pub modification_time: ::fidl_next::wire::Uint64,
10899    }
10900
10901    static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes>(), 56);
10902    static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes>(), 8);
10903
10904    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, mode), 0);
10905
10906    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, id), 8);
10907
10908    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, content_size), 16);
10909
10910    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, storage_size), 24);
10911
10912    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, link_count), 32);
10913
10914    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeAttributes, creation_time), 40);
10915
10916    static_assertions::const_assert_eq!(
10917        std::mem::offset_of!(NodeAttributes, modification_time),
10918        48
10919    );
10920
10921    impl ::fidl_next::Constrained for NodeAttributes {
10922        type Constraint = ();
10923
10924        fn validate(
10925            _: ::fidl_next::Slot<'_, Self>,
10926            _: Self::Constraint,
10927        ) -> Result<(), ::fidl_next::ValidationError> {
10928            Ok(())
10929        }
10930    }
10931
10932    unsafe impl ::fidl_next::Wire for NodeAttributes {
10933        type Narrowed<'de> = NodeAttributes;
10934
10935        #[inline]
10936        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
10937            ::fidl_next::munge! {
10938                let Self {
10939                    mode,
10940                    id,
10941                    content_size,
10942                    storage_size,
10943                    link_count,
10944                    creation_time,
10945                    modification_time,
10946
10947                } = &mut *out_;
10948            }
10949
10950            ::fidl_next::Wire::zero_padding(mode);
10951
10952            ::fidl_next::Wire::zero_padding(id);
10953
10954            ::fidl_next::Wire::zero_padding(content_size);
10955
10956            ::fidl_next::Wire::zero_padding(storage_size);
10957
10958            ::fidl_next::Wire::zero_padding(link_count);
10959
10960            ::fidl_next::Wire::zero_padding(creation_time);
10961
10962            ::fidl_next::Wire::zero_padding(modification_time);
10963
10964            unsafe {
10965                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
10966            }
10967        }
10968    }
10969
10970    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributes
10971    where
10972        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
10973    {
10974        fn decode(
10975            slot_: ::fidl_next::Slot<'_, Self>,
10976            decoder_: &mut ___D,
10977            _: (),
10978        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
10979            if slot_.as_bytes()[4..8] != [0u8; 4] {
10980                return Err(::fidl_next::DecodeError::InvalidPadding);
10981            }
10982
10983            ::fidl_next::munge! {
10984                let Self {
10985                    mut mode,
10986                    mut id,
10987                    mut content_size,
10988                    mut storage_size,
10989                    mut link_count,
10990                    mut creation_time,
10991                    mut modification_time,
10992
10993                } = slot_;
10994            }
10995
10996            let _field = mode.as_mut();
10997
10998            ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
10999
11000            let _field = id.as_mut();
11001
11002            ::fidl_next::Decode::decode(id.as_mut(), decoder_, ())?;
11003
11004            let _field = content_size.as_mut();
11005
11006            ::fidl_next::Decode::decode(content_size.as_mut(), decoder_, ())?;
11007
11008            let _field = storage_size.as_mut();
11009
11010            ::fidl_next::Decode::decode(storage_size.as_mut(), decoder_, ())?;
11011
11012            let _field = link_count.as_mut();
11013
11014            ::fidl_next::Decode::decode(link_count.as_mut(), decoder_, ())?;
11015
11016            let _field = creation_time.as_mut();
11017
11018            ::fidl_next::Decode::decode(creation_time.as_mut(), decoder_, ())?;
11019
11020            let _field = modification_time.as_mut();
11021
11022            ::fidl_next::Decode::decode(modification_time.as_mut(), decoder_, ())?;
11023
11024            Ok(())
11025        }
11026    }
11027
11028    impl ::fidl_next::IntoNatural for NodeAttributes {
11029        type Natural = crate::natural::NodeAttributes;
11030    }
11031
11032    /// The wire type corresponding to [`NodeAttributeFlags`](crate::natural::NodeAttributeFlags).
11033    #[derive(Clone, Copy, Debug)]
11034    #[repr(transparent)]
11035    pub struct NodeAttributeFlags {
11036        pub(crate) value: ::fidl_next::wire::Uint32,
11037    }
11038
11039    impl ::fidl_next::Constrained for NodeAttributeFlags {
11040        type Constraint = ();
11041
11042        fn validate(
11043            _: ::fidl_next::Slot<'_, Self>,
11044            _: Self::Constraint,
11045        ) -> Result<(), ::fidl_next::ValidationError> {
11046            Ok(())
11047        }
11048    }
11049
11050    unsafe impl ::fidl_next::Wire for NodeAttributeFlags {
11051        type Narrowed<'de> = Self;
11052
11053        #[inline]
11054        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11055            // Wire bits have no padding
11056        }
11057    }
11058
11059    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributeFlags
11060    where
11061        ___D: ?Sized,
11062    {
11063        fn decode(
11064            slot: ::fidl_next::Slot<'_, Self>,
11065            _: &mut ___D,
11066            _: (),
11067        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11068            ::fidl_next::munge!(let Self { value } = slot);
11069            let set = u32::from(*value);
11070            if set & !crate::natural::NodeAttributeFlags::all().bits() != 0 {
11071                return Err(::fidl_next::DecodeError::InvalidBits {
11072                    expected: crate::natural::NodeAttributeFlags::all().bits() as usize,
11073                    actual: set as usize,
11074                });
11075            }
11076
11077            Ok(())
11078        }
11079    }
11080
11081    impl ::core::convert::From<crate::natural::NodeAttributeFlags> for NodeAttributeFlags {
11082        fn from(natural: crate::natural::NodeAttributeFlags) -> Self {
11083            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11084        }
11085    }
11086
11087    impl ::fidl_next::IntoNatural for NodeAttributeFlags {
11088        type Natural = crate::natural::NodeAttributeFlags;
11089    }
11090
11091    /// The wire type corresponding to [`NodeQueryFilesystemResponse`].
11092    #[derive(Debug)]
11093    #[repr(C)]
11094    pub struct NodeQueryFilesystemResponse<'de> {
11095        pub s: ::fidl_next::wire::fuchsia::Status,
11096
11097        pub info: ::fidl_next::wire::Box<'de, crate::wire::FilesystemInfo>,
11098    }
11099
11100    static_assertions::const_assert_eq!(std::mem::size_of::<NodeQueryFilesystemResponse<'_>>(), 16);
11101    static_assertions::const_assert_eq!(std::mem::align_of::<NodeQueryFilesystemResponse<'_>>(), 8);
11102
11103    static_assertions::const_assert_eq!(
11104        std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, s),
11105        0
11106    );
11107
11108    static_assertions::const_assert_eq!(
11109        std::mem::offset_of!(NodeQueryFilesystemResponse<'_>, info),
11110        8
11111    );
11112
11113    impl ::fidl_next::Constrained for NodeQueryFilesystemResponse<'_> {
11114        type Constraint = ();
11115
11116        fn validate(
11117            _: ::fidl_next::Slot<'_, Self>,
11118            _: Self::Constraint,
11119        ) -> Result<(), ::fidl_next::ValidationError> {
11120            Ok(())
11121        }
11122    }
11123
11124    unsafe impl ::fidl_next::Wire for NodeQueryFilesystemResponse<'static> {
11125        type Narrowed<'de> = NodeQueryFilesystemResponse<'de>;
11126
11127        #[inline]
11128        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11129            ::fidl_next::munge! {
11130                let Self {
11131                    s,
11132                    info,
11133
11134                } = &mut *out_;
11135            }
11136
11137            ::fidl_next::Wire::zero_padding(s);
11138
11139            ::fidl_next::Wire::zero_padding(info);
11140
11141            unsafe {
11142                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
11143            }
11144        }
11145    }
11146
11147    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeQueryFilesystemResponse<'de>
11148    where
11149        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11150        ___D: ::fidl_next::Decoder<'de>,
11151    {
11152        fn decode(
11153            slot_: ::fidl_next::Slot<'_, Self>,
11154            decoder_: &mut ___D,
11155            _: (),
11156        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11157            if slot_.as_bytes()[4..8] != [0u8; 4] {
11158                return Err(::fidl_next::DecodeError::InvalidPadding);
11159            }
11160
11161            ::fidl_next::munge! {
11162                let Self {
11163                    mut s,
11164                    mut info,
11165
11166                } = slot_;
11167            }
11168
11169            let _field = s.as_mut();
11170
11171            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11172
11173            let _field = info.as_mut();
11174
11175            ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
11176
11177            Ok(())
11178        }
11179    }
11180
11181    impl<'de> ::fidl_next::IntoNatural for NodeQueryFilesystemResponse<'de> {
11182        type Natural = crate::natural::NodeQueryFilesystemResponse;
11183    }
11184
11185    /// The wire type corresponding to [`NodeUpdateAttributesResponse`].
11186    pub type NodeUpdateAttributesResponse = ::fidl_next::wire::Unit;
11187
11188    /// The wire type corresponding to [`NodeSyncResponse`].
11189    pub type NodeSyncResponse = ::fidl_next::wire::Unit;
11190
11191    /// The wire type corresponding to [`ModeType`](crate::natural::ModeType).
11192    #[derive(Clone, Copy, Debug)]
11193    #[repr(transparent)]
11194    pub struct ModeType {
11195        pub(crate) value: ::fidl_next::wire::Uint32,
11196    }
11197
11198    impl ::fidl_next::Constrained for ModeType {
11199        type Constraint = ();
11200
11201        fn validate(
11202            _: ::fidl_next::Slot<'_, Self>,
11203            _: Self::Constraint,
11204        ) -> Result<(), ::fidl_next::ValidationError> {
11205            Ok(())
11206        }
11207    }
11208
11209    unsafe impl ::fidl_next::Wire for ModeType {
11210        type Narrowed<'de> = Self;
11211
11212        #[inline]
11213        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11214            // Wire bits have no padding
11215        }
11216    }
11217
11218    unsafe impl<___D> ::fidl_next::Decode<___D> for ModeType
11219    where
11220        ___D: ?Sized,
11221    {
11222        fn decode(
11223            slot: ::fidl_next::Slot<'_, Self>,
11224            _: &mut ___D,
11225            _: (),
11226        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11227            ::fidl_next::munge!(let Self { value } = slot);
11228            let set = u32::from(*value);
11229            if set & !crate::natural::ModeType::all().bits() != 0 {
11230                return Err(::fidl_next::DecodeError::InvalidBits {
11231                    expected: crate::natural::ModeType::all().bits() as usize,
11232                    actual: set as usize,
11233                });
11234            }
11235
11236            Ok(())
11237        }
11238    }
11239
11240    impl ::core::convert::From<crate::natural::ModeType> for ModeType {
11241        fn from(natural: crate::natural::ModeType) -> Self {
11242            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11243        }
11244    }
11245
11246    impl ::fidl_next::IntoNatural for ModeType {
11247        type Natural = crate::natural::ModeType;
11248    }
11249
11250    /// The wire type corresponding to [`Path`](crate::natural::Path).
11251    pub type Path<'de> = ::fidl_next::wire::String<'de>;
11252
11253    /// The wire type corresponding to [`DirectoryReadDirentsRequest`].
11254    #[derive(Clone, Debug)]
11255    #[repr(C)]
11256    pub struct DirectoryReadDirentsRequest {
11257        pub max_bytes: ::fidl_next::wire::Uint64,
11258    }
11259
11260    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryReadDirentsRequest>(), 8);
11261    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryReadDirentsRequest>(), 8);
11262
11263    static_assertions::const_assert_eq!(
11264        std::mem::offset_of!(DirectoryReadDirentsRequest, max_bytes),
11265        0
11266    );
11267
11268    impl ::fidl_next::Constrained for DirectoryReadDirentsRequest {
11269        type Constraint = ();
11270
11271        fn validate(
11272            _: ::fidl_next::Slot<'_, Self>,
11273            _: Self::Constraint,
11274        ) -> Result<(), ::fidl_next::ValidationError> {
11275            Ok(())
11276        }
11277    }
11278
11279    unsafe impl ::fidl_next::Wire for DirectoryReadDirentsRequest {
11280        type Narrowed<'de> = DirectoryReadDirentsRequest;
11281
11282        #[inline]
11283        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11284            ::fidl_next::munge! {
11285                let Self {
11286                    max_bytes,
11287
11288                } = &mut *out_;
11289            }
11290
11291            ::fidl_next::Wire::zero_padding(max_bytes);
11292        }
11293    }
11294
11295    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsRequest
11296    where
11297        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11298    {
11299        fn decode(
11300            slot_: ::fidl_next::Slot<'_, Self>,
11301            decoder_: &mut ___D,
11302            _: (),
11303        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11304            ::fidl_next::munge! {
11305                let Self {
11306                    mut max_bytes,
11307
11308                } = slot_;
11309            }
11310
11311            let _field = max_bytes.as_mut();
11312
11313            ::fidl_next::Decode::decode(max_bytes.as_mut(), decoder_, ())?;
11314
11315            Ok(())
11316        }
11317    }
11318
11319    impl ::fidl_next::IntoNatural for DirectoryReadDirentsRequest {
11320        type Natural = crate::natural::DirectoryReadDirentsRequest;
11321    }
11322
11323    /// The wire type corresponding to [`DirectoryReadDirentsResponse`].
11324    #[derive(Debug)]
11325    #[repr(C)]
11326    pub struct DirectoryReadDirentsResponse<'de> {
11327        pub s: ::fidl_next::wire::fuchsia::Status,
11328
11329        pub dirents: ::fidl_next::wire::Vector<'de, u8>,
11330    }
11331
11332    static_assertions::const_assert_eq!(
11333        std::mem::size_of::<DirectoryReadDirentsResponse<'_>>(),
11334        24
11335    );
11336    static_assertions::const_assert_eq!(
11337        std::mem::align_of::<DirectoryReadDirentsResponse<'_>>(),
11338        8
11339    );
11340
11341    static_assertions::const_assert_eq!(
11342        std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, s),
11343        0
11344    );
11345
11346    static_assertions::const_assert_eq!(
11347        std::mem::offset_of!(DirectoryReadDirentsResponse<'_>, dirents),
11348        8
11349    );
11350
11351    impl ::fidl_next::Constrained for DirectoryReadDirentsResponse<'_> {
11352        type Constraint = ();
11353
11354        fn validate(
11355            _: ::fidl_next::Slot<'_, Self>,
11356            _: Self::Constraint,
11357        ) -> Result<(), ::fidl_next::ValidationError> {
11358            Ok(())
11359        }
11360    }
11361
11362    unsafe impl ::fidl_next::Wire for DirectoryReadDirentsResponse<'static> {
11363        type Narrowed<'de> = DirectoryReadDirentsResponse<'de>;
11364
11365        #[inline]
11366        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11367            ::fidl_next::munge! {
11368                let Self {
11369                    s,
11370                    dirents,
11371
11372                } = &mut *out_;
11373            }
11374
11375            ::fidl_next::Wire::zero_padding(s);
11376
11377            ::fidl_next::Wire::zero_padding(dirents);
11378
11379            unsafe {
11380                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
11381            }
11382        }
11383    }
11384
11385    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryReadDirentsResponse<'de>
11386    where
11387        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11388        ___D: ::fidl_next::Decoder<'de>,
11389    {
11390        fn decode(
11391            slot_: ::fidl_next::Slot<'_, Self>,
11392            decoder_: &mut ___D,
11393            _: (),
11394        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11395            if slot_.as_bytes()[4..8] != [0u8; 4] {
11396                return Err(::fidl_next::DecodeError::InvalidPadding);
11397            }
11398
11399            ::fidl_next::munge! {
11400                let Self {
11401                    mut s,
11402                    mut dirents,
11403
11404                } = slot_;
11405            }
11406
11407            let _field = s.as_mut();
11408
11409            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11410
11411            let _field = dirents.as_mut();
11412            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
11413            ::fidl_next::Decode::decode(dirents.as_mut(), decoder_, (8192, ()))?;
11414
11415            let dirents = unsafe { dirents.deref_unchecked() };
11416
11417            if dirents.len() > 8192 {
11418                return Err(::fidl_next::DecodeError::VectorTooLong {
11419                    size: dirents.len() as u64,
11420                    limit: 8192,
11421                });
11422            }
11423
11424            Ok(())
11425        }
11426    }
11427
11428    impl<'de> ::fidl_next::IntoNatural for DirectoryReadDirentsResponse<'de> {
11429        type Natural = crate::natural::DirectoryReadDirentsResponse;
11430    }
11431
11432    /// The wire type corresponding to [`DirectoryRewindResponse`].
11433    #[derive(Clone, Debug)]
11434    #[repr(C)]
11435    pub struct DirectoryRewindResponse {
11436        pub s: ::fidl_next::wire::fuchsia::Status,
11437    }
11438
11439    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRewindResponse>(), 4);
11440    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRewindResponse>(), 4);
11441
11442    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRewindResponse, s), 0);
11443
11444    impl ::fidl_next::Constrained for DirectoryRewindResponse {
11445        type Constraint = ();
11446
11447        fn validate(
11448            _: ::fidl_next::Slot<'_, Self>,
11449            _: Self::Constraint,
11450        ) -> Result<(), ::fidl_next::ValidationError> {
11451            Ok(())
11452        }
11453    }
11454
11455    unsafe impl ::fidl_next::Wire for DirectoryRewindResponse {
11456        type Narrowed<'de> = DirectoryRewindResponse;
11457
11458        #[inline]
11459        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11460            ::fidl_next::munge! {
11461                let Self {
11462                    s,
11463
11464                } = &mut *out_;
11465            }
11466
11467            ::fidl_next::Wire::zero_padding(s);
11468        }
11469    }
11470
11471    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryRewindResponse
11472    where
11473        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11474    {
11475        fn decode(
11476            slot_: ::fidl_next::Slot<'_, Self>,
11477            decoder_: &mut ___D,
11478            _: (),
11479        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11480            ::fidl_next::munge! {
11481                let Self {
11482                    mut s,
11483
11484                } = slot_;
11485            }
11486
11487            let _field = s.as_mut();
11488
11489            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11490
11491            Ok(())
11492        }
11493    }
11494
11495    impl ::fidl_next::IntoNatural for DirectoryRewindResponse {
11496        type Natural = crate::natural::DirectoryRewindResponse;
11497    }
11498
11499    /// The wire type corresponding to [`Name`](crate::natural::Name).
11500    pub type Name<'de> = ::fidl_next::wire::String<'de>;
11501
11502    /// The wire type corresponding to [`DirectoryLinkResponse`].
11503    #[derive(Clone, Debug)]
11504    #[repr(C)]
11505    pub struct DirectoryLinkResponse {
11506        pub s: ::fidl_next::wire::fuchsia::Status,
11507    }
11508
11509    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkResponse>(), 4);
11510    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkResponse>(), 4);
11511
11512    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkResponse, s), 0);
11513
11514    impl ::fidl_next::Constrained for DirectoryLinkResponse {
11515        type Constraint = ();
11516
11517        fn validate(
11518            _: ::fidl_next::Slot<'_, Self>,
11519            _: Self::Constraint,
11520        ) -> Result<(), ::fidl_next::ValidationError> {
11521            Ok(())
11522        }
11523    }
11524
11525    unsafe impl ::fidl_next::Wire for DirectoryLinkResponse {
11526        type Narrowed<'de> = DirectoryLinkResponse;
11527
11528        #[inline]
11529        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11530            ::fidl_next::munge! {
11531                let Self {
11532                    s,
11533
11534                } = &mut *out_;
11535            }
11536
11537            ::fidl_next::Wire::zero_padding(s);
11538        }
11539    }
11540
11541    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryLinkResponse
11542    where
11543        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11544    {
11545        fn decode(
11546            slot_: ::fidl_next::Slot<'_, Self>,
11547            decoder_: &mut ___D,
11548            _: (),
11549        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11550            ::fidl_next::munge! {
11551                let Self {
11552                    mut s,
11553
11554                } = slot_;
11555            }
11556
11557            let _field = s.as_mut();
11558
11559            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11560
11561            Ok(())
11562        }
11563    }
11564
11565    impl ::fidl_next::IntoNatural for DirectoryLinkResponse {
11566        type Natural = crate::natural::DirectoryLinkResponse;
11567    }
11568
11569    /// The wire type corresponding to [`UnlinkFlags`](crate::natural::UnlinkFlags).
11570    #[derive(Clone, Copy, Debug)]
11571    #[repr(transparent)]
11572    pub struct UnlinkFlags {
11573        pub(crate) value: ::fidl_next::wire::Uint64,
11574    }
11575
11576    impl ::fidl_next::Constrained for UnlinkFlags {
11577        type Constraint = ();
11578
11579        fn validate(
11580            _: ::fidl_next::Slot<'_, Self>,
11581            _: Self::Constraint,
11582        ) -> Result<(), ::fidl_next::ValidationError> {
11583            Ok(())
11584        }
11585    }
11586
11587    unsafe impl ::fidl_next::Wire for UnlinkFlags {
11588        type Narrowed<'de> = Self;
11589
11590        #[inline]
11591        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11592            // Wire bits have no padding
11593        }
11594    }
11595
11596    unsafe impl<___D> ::fidl_next::Decode<___D> for UnlinkFlags
11597    where
11598        ___D: ?Sized,
11599    {
11600        fn decode(
11601            slot: ::fidl_next::Slot<'_, Self>,
11602            _: &mut ___D,
11603            _: (),
11604        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11605            Ok(())
11606        }
11607    }
11608
11609    impl ::core::convert::From<crate::natural::UnlinkFlags> for UnlinkFlags {
11610        fn from(natural: crate::natural::UnlinkFlags) -> Self {
11611            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
11612        }
11613    }
11614
11615    impl ::fidl_next::IntoNatural for UnlinkFlags {
11616        type Natural = crate::natural::UnlinkFlags;
11617    }
11618
11619    /// The wire type corresponding to [`UnlinkOptions`].
11620    #[repr(C)]
11621    pub struct UnlinkOptions<'de> {
11622        pub(crate) table: ::fidl_next::wire::Table<'de>,
11623    }
11624
11625    impl<'de> Drop for UnlinkOptions<'de> {
11626        fn drop(&mut self) {
11627            let _ = self
11628                .table
11629                .get(1)
11630                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::UnlinkFlags>() });
11631        }
11632    }
11633
11634    impl ::fidl_next::Constrained for UnlinkOptions<'_> {
11635        type Constraint = ();
11636
11637        fn validate(
11638            _: ::fidl_next::Slot<'_, Self>,
11639            _: Self::Constraint,
11640        ) -> Result<(), ::fidl_next::ValidationError> {
11641            Ok(())
11642        }
11643    }
11644
11645    unsafe impl ::fidl_next::Wire for UnlinkOptions<'static> {
11646        type Narrowed<'de> = UnlinkOptions<'de>;
11647
11648        #[inline]
11649        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
11650            ::fidl_next::munge!(let Self { table } = out);
11651            ::fidl_next::wire::Table::zero_padding(table);
11652        }
11653    }
11654
11655    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnlinkOptions<'de>
11656    where
11657        ___D: ::fidl_next::Decoder<'de> + ?Sized,
11658    {
11659        fn decode(
11660            slot: ::fidl_next::Slot<'_, Self>,
11661            decoder: &mut ___D,
11662            _: (),
11663        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11664            ::fidl_next::munge!(let Self { table } = slot);
11665
11666            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
11667                match ordinal {
11668                    0 => unsafe { ::core::hint::unreachable_unchecked() },
11669
11670                    1 => {
11671                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::UnlinkFlags>(
11672                            slot.as_mut(),
11673                            decoder,
11674                            (),
11675                        )?;
11676
11677                        Ok(())
11678                    }
11679
11680                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
11681                }
11682            })
11683        }
11684    }
11685
11686    impl<'de> UnlinkOptions<'de> {
11687        pub fn flags(&self) -> ::core::option::Option<&crate::wire::UnlinkFlags> {
11688            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
11689        }
11690
11691        pub fn take_flags(&mut self) -> ::core::option::Option<crate::wire::UnlinkFlags> {
11692            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
11693        }
11694    }
11695
11696    impl<'de> ::core::fmt::Debug for UnlinkOptions<'de> {
11697        fn fmt(
11698            &self,
11699            f: &mut ::core::fmt::Formatter<'_>,
11700        ) -> ::core::result::Result<(), ::core::fmt::Error> {
11701            f.debug_struct("UnlinkOptions").field("flags", &self.flags()).finish()
11702        }
11703    }
11704
11705    impl<'de> ::fidl_next::IntoNatural for UnlinkOptions<'de> {
11706        type Natural = crate::natural::UnlinkOptions;
11707    }
11708
11709    /// The wire type corresponding to [`DirectoryUnlinkRequest`].
11710    #[derive(Debug)]
11711    #[repr(C)]
11712    pub struct DirectoryUnlinkRequest<'de> {
11713        pub name: ::fidl_next::wire::String<'de>,
11714
11715        pub options: crate::wire::UnlinkOptions<'de>,
11716    }
11717
11718    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryUnlinkRequest<'_>>(), 32);
11719    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryUnlinkRequest<'_>>(), 8);
11720
11721    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryUnlinkRequest<'_>, name), 0);
11722
11723    static_assertions::const_assert_eq!(
11724        std::mem::offset_of!(DirectoryUnlinkRequest<'_>, options),
11725        16
11726    );
11727
11728    impl ::fidl_next::Constrained for DirectoryUnlinkRequest<'_> {
11729        type Constraint = ();
11730
11731        fn validate(
11732            _: ::fidl_next::Slot<'_, Self>,
11733            _: Self::Constraint,
11734        ) -> Result<(), ::fidl_next::ValidationError> {
11735            Ok(())
11736        }
11737    }
11738
11739    unsafe impl ::fidl_next::Wire for DirectoryUnlinkRequest<'static> {
11740        type Narrowed<'de> = DirectoryUnlinkRequest<'de>;
11741
11742        #[inline]
11743        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11744            ::fidl_next::munge! {
11745                let Self {
11746                    name,
11747                    options,
11748
11749                } = &mut *out_;
11750            }
11751
11752            ::fidl_next::Wire::zero_padding(name);
11753
11754            ::fidl_next::Wire::zero_padding(options);
11755        }
11756    }
11757
11758    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryUnlinkRequest<'de>
11759    where
11760        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11761        ___D: ::fidl_next::Decoder<'de>,
11762    {
11763        fn decode(
11764            slot_: ::fidl_next::Slot<'_, Self>,
11765            decoder_: &mut ___D,
11766            _: (),
11767        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11768            ::fidl_next::munge! {
11769                let Self {
11770                    mut name,
11771                    mut options,
11772
11773                } = slot_;
11774            }
11775
11776            let _field = name.as_mut();
11777            ::fidl_next::Constrained::validate(_field, 255)?;
11778            ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
11779
11780            let name = unsafe { name.deref_unchecked() };
11781
11782            if name.len() > 255 {
11783                return Err(::fidl_next::DecodeError::VectorTooLong {
11784                    size: name.len() as u64,
11785                    limit: 255,
11786                });
11787            }
11788
11789            let _field = options.as_mut();
11790
11791            ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
11792
11793            Ok(())
11794        }
11795    }
11796
11797    impl<'de> ::fidl_next::IntoNatural for DirectoryUnlinkRequest<'de> {
11798        type Natural = crate::natural::DirectoryUnlinkRequest;
11799    }
11800
11801    /// The wire type corresponding to [`DirectoryUnlinkResponse`].
11802    pub type DirectoryUnlinkResponse = ::fidl_next::wire::Unit;
11803
11804    /// The wire type corresponding to [`DirectoryRenameResponse`].
11805    pub type DirectoryRenameResponse = ::fidl_next::wire::Unit;
11806
11807    /// The wire type corresponding to [`WatchMask`](crate::natural::WatchMask).
11808    #[derive(Clone, Copy, Debug)]
11809    #[repr(transparent)]
11810    pub struct WatchMask {
11811        pub(crate) value: ::fidl_next::wire::Uint32,
11812    }
11813
11814    impl ::fidl_next::Constrained for WatchMask {
11815        type Constraint = ();
11816
11817        fn validate(
11818            _: ::fidl_next::Slot<'_, Self>,
11819            _: Self::Constraint,
11820        ) -> Result<(), ::fidl_next::ValidationError> {
11821            Ok(())
11822        }
11823    }
11824
11825    unsafe impl ::fidl_next::Wire for WatchMask {
11826        type Narrowed<'de> = Self;
11827
11828        #[inline]
11829        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
11830            // Wire bits have no padding
11831        }
11832    }
11833
11834    unsafe impl<___D> ::fidl_next::Decode<___D> for WatchMask
11835    where
11836        ___D: ?Sized,
11837    {
11838        fn decode(
11839            slot: ::fidl_next::Slot<'_, Self>,
11840            _: &mut ___D,
11841            _: (),
11842        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11843            ::fidl_next::munge!(let Self { value } = slot);
11844            let set = u32::from(*value);
11845            if set & !crate::natural::WatchMask::all().bits() != 0 {
11846                return Err(::fidl_next::DecodeError::InvalidBits {
11847                    expected: crate::natural::WatchMask::all().bits() as usize,
11848                    actual: set as usize,
11849                });
11850            }
11851
11852            Ok(())
11853        }
11854    }
11855
11856    impl ::core::convert::From<crate::natural::WatchMask> for WatchMask {
11857        fn from(natural: crate::natural::WatchMask) -> Self {
11858            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
11859        }
11860    }
11861
11862    impl ::fidl_next::IntoNatural for WatchMask {
11863        type Natural = crate::natural::WatchMask;
11864    }
11865
11866    /// The wire type corresponding to [`DirectoryWatchResponse`].
11867    #[derive(Clone, Debug)]
11868    #[repr(C)]
11869    pub struct DirectoryWatchResponse {
11870        pub s: ::fidl_next::wire::fuchsia::Status,
11871    }
11872
11873    static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchResponse>(), 4);
11874    static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchResponse>(), 4);
11875
11876    static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchResponse, s), 0);
11877
11878    impl ::fidl_next::Constrained for DirectoryWatchResponse {
11879        type Constraint = ();
11880
11881        fn validate(
11882            _: ::fidl_next::Slot<'_, Self>,
11883            _: Self::Constraint,
11884        ) -> Result<(), ::fidl_next::ValidationError> {
11885            Ok(())
11886        }
11887    }
11888
11889    unsafe impl ::fidl_next::Wire for DirectoryWatchResponse {
11890        type Narrowed<'de> = DirectoryWatchResponse;
11891
11892        #[inline]
11893        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11894            ::fidl_next::munge! {
11895                let Self {
11896                    s,
11897
11898                } = &mut *out_;
11899            }
11900
11901            ::fidl_next::Wire::zero_padding(s);
11902        }
11903    }
11904
11905    unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchResponse
11906    where
11907        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11908    {
11909        fn decode(
11910            slot_: ::fidl_next::Slot<'_, Self>,
11911            decoder_: &mut ___D,
11912            _: (),
11913        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11914            ::fidl_next::munge! {
11915                let Self {
11916                    mut s,
11917
11918                } = slot_;
11919            }
11920
11921            let _field = s.as_mut();
11922
11923            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
11924
11925            Ok(())
11926        }
11927    }
11928
11929    impl ::fidl_next::IntoNatural for DirectoryWatchResponse {
11930        type Natural = crate::natural::DirectoryWatchResponse;
11931    }
11932
11933    /// The wire type corresponding to [`SymlinkTarget`](crate::natural::SymlinkTarget).
11934    pub type SymlinkTarget<'de> = ::fidl_next::wire::Vector<'de, u8>;
11935
11936    /// The wire type corresponding to [`ExtendedAttributeName`](crate::natural::ExtendedAttributeName).
11937    pub type ExtendedAttributeName<'de> = ::fidl_next::wire::Vector<'de, u8>;
11938
11939    /// The wire type corresponding to [`NodeGetExtendedAttributeRequest`].
11940    #[derive(Debug)]
11941    #[repr(C)]
11942    pub struct NodeGetExtendedAttributeRequest<'de> {
11943        pub name: ::fidl_next::wire::Vector<'de, u8>,
11944    }
11945
11946    static_assertions::const_assert_eq!(
11947        std::mem::size_of::<NodeGetExtendedAttributeRequest<'_>>(),
11948        16
11949    );
11950    static_assertions::const_assert_eq!(
11951        std::mem::align_of::<NodeGetExtendedAttributeRequest<'_>>(),
11952        8
11953    );
11954
11955    static_assertions::const_assert_eq!(
11956        std::mem::offset_of!(NodeGetExtendedAttributeRequest<'_>, name),
11957        0
11958    );
11959
11960    impl ::fidl_next::Constrained for NodeGetExtendedAttributeRequest<'_> {
11961        type Constraint = ();
11962
11963        fn validate(
11964            _: ::fidl_next::Slot<'_, Self>,
11965            _: Self::Constraint,
11966        ) -> Result<(), ::fidl_next::ValidationError> {
11967            Ok(())
11968        }
11969    }
11970
11971    unsafe impl ::fidl_next::Wire for NodeGetExtendedAttributeRequest<'static> {
11972        type Narrowed<'de> = NodeGetExtendedAttributeRequest<'de>;
11973
11974        #[inline]
11975        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
11976            ::fidl_next::munge! {
11977                let Self {
11978                    name,
11979
11980                } = &mut *out_;
11981            }
11982
11983            ::fidl_next::Wire::zero_padding(name);
11984        }
11985    }
11986
11987    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeGetExtendedAttributeRequest<'de>
11988    where
11989        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
11990        ___D: ::fidl_next::Decoder<'de>,
11991    {
11992        fn decode(
11993            slot_: ::fidl_next::Slot<'_, Self>,
11994            decoder_: &mut ___D,
11995            _: (),
11996        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
11997            ::fidl_next::munge! {
11998                let Self {
11999                    mut name,
12000
12001                } = slot_;
12002            }
12003
12004            let _field = name.as_mut();
12005            ::fidl_next::Constrained::validate(_field, (255, ()))?;
12006            ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
12007
12008            let name = unsafe { name.deref_unchecked() };
12009
12010            if name.len() > 255 {
12011                return Err(::fidl_next::DecodeError::VectorTooLong {
12012                    size: name.len() as u64,
12013                    limit: 255,
12014                });
12015            }
12016
12017            Ok(())
12018        }
12019    }
12020
12021    impl<'de> ::fidl_next::IntoNatural for NodeGetExtendedAttributeRequest<'de> {
12022        type Natural = crate::natural::NodeGetExtendedAttributeRequest;
12023    }
12024
12025    /// The wire type corresponding to [`SetExtendedAttributeMode`].
12026    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
12027    #[repr(transparent)]
12028    pub struct SetExtendedAttributeMode {
12029        pub(crate) value: ::fidl_next::wire::Uint32,
12030    }
12031
12032    impl ::fidl_next::Constrained for SetExtendedAttributeMode {
12033        type Constraint = ();
12034
12035        fn validate(
12036            _: ::fidl_next::Slot<'_, Self>,
12037            _: Self::Constraint,
12038        ) -> Result<(), ::fidl_next::ValidationError> {
12039            Ok(())
12040        }
12041    }
12042
12043    unsafe impl ::fidl_next::Wire for SetExtendedAttributeMode {
12044        type Narrowed<'de> = Self;
12045
12046        #[inline]
12047        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12048            // Wire enums have no padding
12049        }
12050    }
12051
12052    impl SetExtendedAttributeMode {
12053        pub const SET: SetExtendedAttributeMode =
12054            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(1) };
12055
12056        pub const CREATE: SetExtendedAttributeMode =
12057            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(2) };
12058
12059        pub const REPLACE: SetExtendedAttributeMode =
12060            SetExtendedAttributeMode { value: ::fidl_next::wire::Uint32(3) };
12061    }
12062
12063    unsafe impl<___D> ::fidl_next::Decode<___D> for SetExtendedAttributeMode
12064    where
12065        ___D: ?Sized,
12066    {
12067        fn decode(
12068            slot: ::fidl_next::Slot<'_, Self>,
12069            _: &mut ___D,
12070            _: (),
12071        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12072            ::fidl_next::munge!(let Self { value } = slot);
12073
12074            match u32::from(*value) {
12075                1 | 2 | 3 => (),
12076                unknown => {
12077                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
12078                }
12079            }
12080
12081            Ok(())
12082        }
12083    }
12084
12085    impl ::core::convert::From<crate::natural::SetExtendedAttributeMode> for SetExtendedAttributeMode {
12086        fn from(natural: crate::natural::SetExtendedAttributeMode) -> Self {
12087            match natural {
12088                crate::natural::SetExtendedAttributeMode::Set => SetExtendedAttributeMode::SET,
12089
12090                crate::natural::SetExtendedAttributeMode::Create => {
12091                    SetExtendedAttributeMode::CREATE
12092                }
12093
12094                crate::natural::SetExtendedAttributeMode::Replace => {
12095                    SetExtendedAttributeMode::REPLACE
12096                }
12097            }
12098        }
12099    }
12100
12101    impl ::fidl_next::IntoNatural for SetExtendedAttributeMode {
12102        type Natural = crate::natural::SetExtendedAttributeMode;
12103    }
12104
12105    /// The wire type corresponding to [`NodeSetExtendedAttributeResponse`].
12106    pub type NodeSetExtendedAttributeResponse = ::fidl_next::wire::Unit;
12107
12108    /// The wire type corresponding to [`NodeRemoveExtendedAttributeRequest`].
12109    #[derive(Debug)]
12110    #[repr(C)]
12111    pub struct NodeRemoveExtendedAttributeRequest<'de> {
12112        pub name: ::fidl_next::wire::Vector<'de, u8>,
12113    }
12114
12115    static_assertions::const_assert_eq!(
12116        std::mem::size_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
12117        16
12118    );
12119    static_assertions::const_assert_eq!(
12120        std::mem::align_of::<NodeRemoveExtendedAttributeRequest<'_>>(),
12121        8
12122    );
12123
12124    static_assertions::const_assert_eq!(
12125        std::mem::offset_of!(NodeRemoveExtendedAttributeRequest<'_>, name),
12126        0
12127    );
12128
12129    impl ::fidl_next::Constrained for NodeRemoveExtendedAttributeRequest<'_> {
12130        type Constraint = ();
12131
12132        fn validate(
12133            _: ::fidl_next::Slot<'_, Self>,
12134            _: Self::Constraint,
12135        ) -> Result<(), ::fidl_next::ValidationError> {
12136            Ok(())
12137        }
12138    }
12139
12140    unsafe impl ::fidl_next::Wire for NodeRemoveExtendedAttributeRequest<'static> {
12141        type Narrowed<'de> = NodeRemoveExtendedAttributeRequest<'de>;
12142
12143        #[inline]
12144        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12145            ::fidl_next::munge! {
12146                let Self {
12147                    name,
12148
12149                } = &mut *out_;
12150            }
12151
12152            ::fidl_next::Wire::zero_padding(name);
12153        }
12154    }
12155
12156    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeRemoveExtendedAttributeRequest<'de>
12157    where
12158        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12159        ___D: ::fidl_next::Decoder<'de>,
12160    {
12161        fn decode(
12162            slot_: ::fidl_next::Slot<'_, Self>,
12163            decoder_: &mut ___D,
12164            _: (),
12165        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12166            ::fidl_next::munge! {
12167                let Self {
12168                    mut name,
12169
12170                } = slot_;
12171            }
12172
12173            let _field = name.as_mut();
12174            ::fidl_next::Constrained::validate(_field, (255, ()))?;
12175            ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
12176
12177            let name = unsafe { name.deref_unchecked() };
12178
12179            if name.len() > 255 {
12180                return Err(::fidl_next::DecodeError::VectorTooLong {
12181                    size: name.len() as u64,
12182                    limit: 255,
12183                });
12184            }
12185
12186            Ok(())
12187        }
12188    }
12189
12190    impl<'de> ::fidl_next::IntoNatural for NodeRemoveExtendedAttributeRequest<'de> {
12191        type Natural = crate::natural::NodeRemoveExtendedAttributeRequest;
12192    }
12193
12194    /// The wire type corresponding to [`NodeRemoveExtendedAttributeResponse`].
12195    pub type NodeRemoveExtendedAttributeResponse = ::fidl_next::wire::Unit;
12196
12197    /// The wire type corresponding to [`DirectoryCreateSymlinkResponse`].
12198    pub type DirectoryCreateSymlinkResponse = ::fidl_next::wire::Unit;
12199
12200    /// The wire type corresponding to [`NodeSetFlagsResponse`].
12201    pub type NodeSetFlagsResponse = ::fidl_next::wire::Unit;
12202
12203    /// The wire type corresponding to [`NodeDeprecatedGetAttrResponse`].
12204    #[derive(Clone, Debug)]
12205    #[repr(C)]
12206    pub struct NodeDeprecatedGetAttrResponse {
12207        pub s: ::fidl_next::wire::fuchsia::Status,
12208
12209        pub attributes: crate::wire::NodeAttributes,
12210    }
12211
12212    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetAttrResponse>(), 64);
12213    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetAttrResponse>(), 8);
12214
12215    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetAttrResponse, s), 0);
12216
12217    static_assertions::const_assert_eq!(
12218        std::mem::offset_of!(NodeDeprecatedGetAttrResponse, attributes),
12219        8
12220    );
12221
12222    impl ::fidl_next::Constrained for NodeDeprecatedGetAttrResponse {
12223        type Constraint = ();
12224
12225        fn validate(
12226            _: ::fidl_next::Slot<'_, Self>,
12227            _: Self::Constraint,
12228        ) -> Result<(), ::fidl_next::ValidationError> {
12229            Ok(())
12230        }
12231    }
12232
12233    unsafe impl ::fidl_next::Wire for NodeDeprecatedGetAttrResponse {
12234        type Narrowed<'de> = NodeDeprecatedGetAttrResponse;
12235
12236        #[inline]
12237        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12238            ::fidl_next::munge! {
12239                let Self {
12240                    s,
12241                    attributes,
12242
12243                } = &mut *out_;
12244            }
12245
12246            ::fidl_next::Wire::zero_padding(s);
12247
12248            ::fidl_next::Wire::zero_padding(attributes);
12249
12250            unsafe {
12251                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
12252            }
12253        }
12254    }
12255
12256    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetAttrResponse
12257    where
12258        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12259    {
12260        fn decode(
12261            slot_: ::fidl_next::Slot<'_, Self>,
12262            decoder_: &mut ___D,
12263            _: (),
12264        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12265            if slot_.as_bytes()[4..8] != [0u8; 4] {
12266                return Err(::fidl_next::DecodeError::InvalidPadding);
12267            }
12268
12269            ::fidl_next::munge! {
12270                let Self {
12271                    mut s,
12272                    mut attributes,
12273
12274                } = slot_;
12275            }
12276
12277            let _field = s.as_mut();
12278
12279            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12280
12281            let _field = attributes.as_mut();
12282
12283            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
12284
12285            Ok(())
12286        }
12287    }
12288
12289    impl ::fidl_next::IntoNatural for NodeDeprecatedGetAttrResponse {
12290        type Natural = crate::natural::NodeDeprecatedGetAttrResponse;
12291    }
12292
12293    /// The wire type corresponding to [`NodeDeprecatedSetAttrRequest`].
12294    #[derive(Clone, Debug)]
12295    #[repr(C)]
12296    pub struct NodeDeprecatedSetAttrRequest {
12297        pub flags: crate::wire::NodeAttributeFlags,
12298
12299        pub attributes: crate::wire::NodeAttributes,
12300    }
12301
12302    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrRequest>(), 64);
12303    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrRequest>(), 8);
12304
12305    static_assertions::const_assert_eq!(
12306        std::mem::offset_of!(NodeDeprecatedSetAttrRequest, flags),
12307        0
12308    );
12309
12310    static_assertions::const_assert_eq!(
12311        std::mem::offset_of!(NodeDeprecatedSetAttrRequest, attributes),
12312        8
12313    );
12314
12315    impl ::fidl_next::Constrained for NodeDeprecatedSetAttrRequest {
12316        type Constraint = ();
12317
12318        fn validate(
12319            _: ::fidl_next::Slot<'_, Self>,
12320            _: Self::Constraint,
12321        ) -> Result<(), ::fidl_next::ValidationError> {
12322            Ok(())
12323        }
12324    }
12325
12326    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrRequest {
12327        type Narrowed<'de> = NodeDeprecatedSetAttrRequest;
12328
12329        #[inline]
12330        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12331            ::fidl_next::munge! {
12332                let Self {
12333                    flags,
12334                    attributes,
12335
12336                } = &mut *out_;
12337            }
12338
12339            ::fidl_next::Wire::zero_padding(flags);
12340
12341            ::fidl_next::Wire::zero_padding(attributes);
12342
12343            unsafe {
12344                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
12345            }
12346        }
12347    }
12348
12349    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrRequest
12350    where
12351        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12352    {
12353        fn decode(
12354            slot_: ::fidl_next::Slot<'_, Self>,
12355            decoder_: &mut ___D,
12356            _: (),
12357        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12358            if slot_.as_bytes()[4..8] != [0u8; 4] {
12359                return Err(::fidl_next::DecodeError::InvalidPadding);
12360            }
12361
12362            ::fidl_next::munge! {
12363                let Self {
12364                    mut flags,
12365                    mut attributes,
12366
12367                } = slot_;
12368            }
12369
12370            let _field = flags.as_mut();
12371
12372            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12373
12374            let _field = attributes.as_mut();
12375
12376            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, ())?;
12377
12378            Ok(())
12379        }
12380    }
12381
12382    impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrRequest {
12383        type Natural = crate::natural::NodeDeprecatedSetAttrRequest;
12384    }
12385
12386    /// The wire type corresponding to [`NodeDeprecatedSetAttrResponse`].
12387    #[derive(Clone, Debug)]
12388    #[repr(C)]
12389    pub struct NodeDeprecatedSetAttrResponse {
12390        pub s: ::fidl_next::wire::fuchsia::Status,
12391    }
12392
12393    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetAttrResponse>(), 4);
12394    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetAttrResponse>(), 4);
12395
12396    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetAttrResponse, s), 0);
12397
12398    impl ::fidl_next::Constrained for NodeDeprecatedSetAttrResponse {
12399        type Constraint = ();
12400
12401        fn validate(
12402            _: ::fidl_next::Slot<'_, Self>,
12403            _: Self::Constraint,
12404        ) -> Result<(), ::fidl_next::ValidationError> {
12405            Ok(())
12406        }
12407    }
12408
12409    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetAttrResponse {
12410        type Narrowed<'de> = NodeDeprecatedSetAttrResponse;
12411
12412        #[inline]
12413        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12414            ::fidl_next::munge! {
12415                let Self {
12416                    s,
12417
12418                } = &mut *out_;
12419            }
12420
12421            ::fidl_next::Wire::zero_padding(s);
12422        }
12423    }
12424
12425    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetAttrResponse
12426    where
12427        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12428    {
12429        fn decode(
12430            slot_: ::fidl_next::Slot<'_, Self>,
12431            decoder_: &mut ___D,
12432            _: (),
12433        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12434            ::fidl_next::munge! {
12435                let Self {
12436                    mut s,
12437
12438                } = slot_;
12439            }
12440
12441            let _field = s.as_mut();
12442
12443            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12444
12445            Ok(())
12446        }
12447    }
12448
12449    impl ::fidl_next::IntoNatural for NodeDeprecatedSetAttrResponse {
12450        type Natural = crate::natural::NodeDeprecatedSetAttrResponse;
12451    }
12452
12453    /// The wire type corresponding to [`NodeDeprecatedGetFlagsResponse`].
12454    #[derive(Clone, Debug)]
12455    #[repr(C)]
12456    pub struct NodeDeprecatedGetFlagsResponse {
12457        pub s: ::fidl_next::wire::fuchsia::Status,
12458
12459        pub flags: crate::wire::OpenFlags,
12460    }
12461
12462    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedGetFlagsResponse>(), 8);
12463    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedGetFlagsResponse>(), 4);
12464
12465    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, s), 0);
12466
12467    static_assertions::const_assert_eq!(
12468        std::mem::offset_of!(NodeDeprecatedGetFlagsResponse, flags),
12469        4
12470    );
12471
12472    impl ::fidl_next::Constrained for NodeDeprecatedGetFlagsResponse {
12473        type Constraint = ();
12474
12475        fn validate(
12476            _: ::fidl_next::Slot<'_, Self>,
12477            _: Self::Constraint,
12478        ) -> Result<(), ::fidl_next::ValidationError> {
12479            Ok(())
12480        }
12481    }
12482
12483    unsafe impl ::fidl_next::Wire for NodeDeprecatedGetFlagsResponse {
12484        type Narrowed<'de> = NodeDeprecatedGetFlagsResponse;
12485
12486        #[inline]
12487        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12488            ::fidl_next::munge! {
12489                let Self {
12490                    s,
12491                    flags,
12492
12493                } = &mut *out_;
12494            }
12495
12496            ::fidl_next::Wire::zero_padding(s);
12497
12498            ::fidl_next::Wire::zero_padding(flags);
12499        }
12500    }
12501
12502    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedGetFlagsResponse
12503    where
12504        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12505    {
12506        fn decode(
12507            slot_: ::fidl_next::Slot<'_, Self>,
12508            decoder_: &mut ___D,
12509            _: (),
12510        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12511            ::fidl_next::munge! {
12512                let Self {
12513                    mut s,
12514                    mut flags,
12515
12516                } = slot_;
12517            }
12518
12519            let _field = s.as_mut();
12520
12521            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12522
12523            let _field = flags.as_mut();
12524
12525            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12526
12527            Ok(())
12528        }
12529    }
12530
12531    impl ::fidl_next::IntoNatural for NodeDeprecatedGetFlagsResponse {
12532        type Natural = crate::natural::NodeDeprecatedGetFlagsResponse;
12533    }
12534
12535    /// The wire type corresponding to [`NodeDeprecatedSetFlagsRequest`].
12536    #[derive(Clone, Debug)]
12537    #[repr(C)]
12538    pub struct NodeDeprecatedSetFlagsRequest {
12539        pub flags: crate::wire::OpenFlags,
12540    }
12541
12542    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsRequest>(), 4);
12543    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsRequest>(), 4);
12544
12545    static_assertions::const_assert_eq!(
12546        std::mem::offset_of!(NodeDeprecatedSetFlagsRequest, flags),
12547        0
12548    );
12549
12550    impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsRequest {
12551        type Constraint = ();
12552
12553        fn validate(
12554            _: ::fidl_next::Slot<'_, Self>,
12555            _: Self::Constraint,
12556        ) -> Result<(), ::fidl_next::ValidationError> {
12557            Ok(())
12558        }
12559    }
12560
12561    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsRequest {
12562        type Narrowed<'de> = NodeDeprecatedSetFlagsRequest;
12563
12564        #[inline]
12565        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12566            ::fidl_next::munge! {
12567                let Self {
12568                    flags,
12569
12570                } = &mut *out_;
12571            }
12572
12573            ::fidl_next::Wire::zero_padding(flags);
12574        }
12575    }
12576
12577    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsRequest
12578    where
12579        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12580    {
12581        fn decode(
12582            slot_: ::fidl_next::Slot<'_, Self>,
12583            decoder_: &mut ___D,
12584            _: (),
12585        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12586            ::fidl_next::munge! {
12587                let Self {
12588                    mut flags,
12589
12590                } = slot_;
12591            }
12592
12593            let _field = flags.as_mut();
12594
12595            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12596
12597            Ok(())
12598        }
12599    }
12600
12601    impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsRequest {
12602        type Natural = crate::natural::NodeDeprecatedSetFlagsRequest;
12603    }
12604
12605    /// The wire type corresponding to [`NodeDeprecatedSetFlagsResponse`].
12606    #[derive(Clone, Debug)]
12607    #[repr(C)]
12608    pub struct NodeDeprecatedSetFlagsResponse {
12609        pub s: ::fidl_next::wire::fuchsia::Status,
12610    }
12611
12612    static_assertions::const_assert_eq!(std::mem::size_of::<NodeDeprecatedSetFlagsResponse>(), 4);
12613    static_assertions::const_assert_eq!(std::mem::align_of::<NodeDeprecatedSetFlagsResponse>(), 4);
12614
12615    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeDeprecatedSetFlagsResponse, s), 0);
12616
12617    impl ::fidl_next::Constrained for NodeDeprecatedSetFlagsResponse {
12618        type Constraint = ();
12619
12620        fn validate(
12621            _: ::fidl_next::Slot<'_, Self>,
12622            _: Self::Constraint,
12623        ) -> Result<(), ::fidl_next::ValidationError> {
12624            Ok(())
12625        }
12626    }
12627
12628    unsafe impl ::fidl_next::Wire for NodeDeprecatedSetFlagsResponse {
12629        type Narrowed<'de> = NodeDeprecatedSetFlagsResponse;
12630
12631        #[inline]
12632        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12633            ::fidl_next::munge! {
12634                let Self {
12635                    s,
12636
12637                } = &mut *out_;
12638            }
12639
12640            ::fidl_next::Wire::zero_padding(s);
12641        }
12642    }
12643
12644    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeDeprecatedSetFlagsResponse
12645    where
12646        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12647    {
12648        fn decode(
12649            slot_: ::fidl_next::Slot<'_, Self>,
12650            decoder_: &mut ___D,
12651            _: (),
12652        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12653            ::fidl_next::munge! {
12654                let Self {
12655                    mut s,
12656
12657                } = slot_;
12658            }
12659
12660            let _field = s.as_mut();
12661
12662            ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
12663
12664            Ok(())
12665        }
12666    }
12667
12668    impl ::fidl_next::IntoNatural for NodeDeprecatedSetFlagsResponse {
12669        type Natural = crate::natural::NodeDeprecatedSetFlagsResponse;
12670    }
12671
12672    /// The wire type corresponding to [`Flags`](crate::natural::Flags).
12673    #[derive(Clone, Copy, Debug)]
12674    #[repr(transparent)]
12675    pub struct Flags {
12676        pub(crate) value: ::fidl_next::wire::Uint64,
12677    }
12678
12679    impl ::fidl_next::Constrained for Flags {
12680        type Constraint = ();
12681
12682        fn validate(
12683            _: ::fidl_next::Slot<'_, Self>,
12684            _: Self::Constraint,
12685        ) -> Result<(), ::fidl_next::ValidationError> {
12686            Ok(())
12687        }
12688    }
12689
12690    unsafe impl ::fidl_next::Wire for Flags {
12691        type Narrowed<'de> = Self;
12692
12693        #[inline]
12694        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
12695            // Wire bits have no padding
12696        }
12697    }
12698
12699    unsafe impl<___D> ::fidl_next::Decode<___D> for Flags
12700    where
12701        ___D: ?Sized,
12702    {
12703        fn decode(
12704            slot: ::fidl_next::Slot<'_, Self>,
12705            _: &mut ___D,
12706            _: (),
12707        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12708            Ok(())
12709        }
12710    }
12711
12712    impl ::core::convert::From<crate::natural::Flags> for Flags {
12713        fn from(natural: crate::natural::Flags) -> Self {
12714            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
12715        }
12716    }
12717
12718    impl ::fidl_next::IntoNatural for Flags {
12719        type Natural = crate::natural::Flags;
12720    }
12721
12722    /// The wire type corresponding to [`NodeGetFlagsResponse`].
12723    #[derive(Clone, Debug)]
12724    #[repr(C)]
12725    pub struct NodeGetFlagsResponse {
12726        pub flags: crate::wire::Flags,
12727    }
12728
12729    static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetFlagsResponse>(), 8);
12730    static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetFlagsResponse>(), 8);
12731
12732    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetFlagsResponse, flags), 0);
12733
12734    impl ::fidl_next::Constrained for NodeGetFlagsResponse {
12735        type Constraint = ();
12736
12737        fn validate(
12738            _: ::fidl_next::Slot<'_, Self>,
12739            _: Self::Constraint,
12740        ) -> Result<(), ::fidl_next::ValidationError> {
12741            Ok(())
12742        }
12743    }
12744
12745    unsafe impl ::fidl_next::Wire for NodeGetFlagsResponse {
12746        type Narrowed<'de> = NodeGetFlagsResponse;
12747
12748        #[inline]
12749        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12750            ::fidl_next::munge! {
12751                let Self {
12752                    flags,
12753
12754                } = &mut *out_;
12755            }
12756
12757            ::fidl_next::Wire::zero_padding(flags);
12758        }
12759    }
12760
12761    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetFlagsResponse
12762    where
12763        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12764    {
12765        fn decode(
12766            slot_: ::fidl_next::Slot<'_, Self>,
12767            decoder_: &mut ___D,
12768            _: (),
12769        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12770            ::fidl_next::munge! {
12771                let Self {
12772                    mut flags,
12773
12774                } = slot_;
12775            }
12776
12777            let _field = flags.as_mut();
12778
12779            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12780
12781            Ok(())
12782        }
12783    }
12784
12785    impl ::fidl_next::IntoNatural for NodeGetFlagsResponse {
12786        type Natural = crate::natural::NodeGetFlagsResponse;
12787    }
12788
12789    /// The wire type corresponding to [`NodeSetFlagsRequest`].
12790    #[derive(Clone, Debug)]
12791    #[repr(C)]
12792    pub struct NodeSetFlagsRequest {
12793        pub flags: crate::wire::Flags,
12794    }
12795
12796    static_assertions::const_assert_eq!(std::mem::size_of::<NodeSetFlagsRequest>(), 8);
12797    static_assertions::const_assert_eq!(std::mem::align_of::<NodeSetFlagsRequest>(), 8);
12798
12799    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeSetFlagsRequest, flags), 0);
12800
12801    impl ::fidl_next::Constrained for NodeSetFlagsRequest {
12802        type Constraint = ();
12803
12804        fn validate(
12805            _: ::fidl_next::Slot<'_, Self>,
12806            _: Self::Constraint,
12807        ) -> Result<(), ::fidl_next::ValidationError> {
12808            Ok(())
12809        }
12810    }
12811
12812    unsafe impl ::fidl_next::Wire for NodeSetFlagsRequest {
12813        type Narrowed<'de> = NodeSetFlagsRequest;
12814
12815        #[inline]
12816        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
12817            ::fidl_next::munge! {
12818                let Self {
12819                    flags,
12820
12821                } = &mut *out_;
12822            }
12823
12824            ::fidl_next::Wire::zero_padding(flags);
12825        }
12826    }
12827
12828    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeSetFlagsRequest
12829    where
12830        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12831    {
12832        fn decode(
12833            slot_: ::fidl_next::Slot<'_, Self>,
12834            decoder_: &mut ___D,
12835            _: (),
12836        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12837            ::fidl_next::munge! {
12838                let Self {
12839                    mut flags,
12840
12841                } = slot_;
12842            }
12843
12844            let _field = flags.as_mut();
12845
12846            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
12847
12848            Ok(())
12849        }
12850    }
12851
12852    impl ::fidl_next::IntoNatural for NodeSetFlagsRequest {
12853        type Natural = crate::natural::NodeSetFlagsRequest;
12854    }
12855
12856    /// The wire type corresponding to [`EmptyStruct`].
12857    pub type EmptyStruct = ::fidl_next::wire::Unit;
12858
12859    /// The wire type corresponding to [`SelinuxContext`].
12860    #[repr(transparent)]
12861    pub struct SelinuxContext<'de> {
12862        pub(crate) raw: ::fidl_next::wire::Union,
12863        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
12864    }
12865
12866    impl<'de> Drop for SelinuxContext<'de> {
12867        fn drop(&mut self) {
12868            match self.raw.ordinal() {
12869                1 => {
12870                    let _ = unsafe {
12871                        self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
12872                    };
12873                }
12874
12875                2 => {
12876                    let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::EmptyStruct>() };
12877                }
12878
12879                _ => (),
12880            }
12881        }
12882    }
12883
12884    impl ::fidl_next::Constrained for SelinuxContext<'_> {
12885        type Constraint = ();
12886
12887        fn validate(
12888            _: ::fidl_next::Slot<'_, Self>,
12889            _: Self::Constraint,
12890        ) -> Result<(), ::fidl_next::ValidationError> {
12891            Ok(())
12892        }
12893    }
12894
12895    unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
12896        type Narrowed<'de> = SelinuxContext<'de>;
12897
12898        #[inline]
12899        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
12900            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
12901            ::fidl_next::wire::Union::zero_padding(raw);
12902        }
12903    }
12904
12905    pub mod selinux_context {
12906        pub enum Ref<'de> {
12907            Data(&'de ::fidl_next::wire::Vector<'de, u8>),
12908
12909            UseExtendedAttributes(&'de crate::wire::EmptyStruct),
12910
12911            UnknownOrdinal_(u64),
12912        }
12913
12914        pub enum Value<'de> {
12915            Data(::fidl_next::wire::Vector<'de, u8>),
12916
12917            UseExtendedAttributes(crate::wire::EmptyStruct),
12918
12919            UnknownOrdinal_(u64),
12920        }
12921    }
12922
12923    impl<'de> SelinuxContext<'de> {
12924        pub fn as_ref(&self) -> crate::wire::selinux_context::Ref<'_> {
12925            match self.raw.ordinal() {
12926                1 => crate::wire::selinux_context::Ref::Data(unsafe {
12927                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
12928                }),
12929
12930                2 => crate::wire::selinux_context::Ref::UseExtendedAttributes(unsafe {
12931                    self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>()
12932                }),
12933
12934                unknown => crate::wire::selinux_context::Ref::UnknownOrdinal_(unknown),
12935            }
12936        }
12937
12938        pub fn into_inner(self) -> crate::wire::selinux_context::Value<'de> {
12939            let this = ::core::mem::ManuallyDrop::new(self);
12940
12941            match this.raw.ordinal() {
12942                1 => crate::wire::selinux_context::Value::Data(unsafe {
12943                    this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
12944                }),
12945
12946                2 => crate::wire::selinux_context::Value::UseExtendedAttributes(unsafe {
12947                    this.raw.get().read_unchecked::<crate::wire::EmptyStruct>()
12948                }),
12949
12950                unknown => crate::wire::selinux_context::Value::UnknownOrdinal_(unknown),
12951            }
12952        }
12953    }
12954
12955    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
12956    where
12957        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
12958        ___D: ::fidl_next::Decoder<'de>,
12959    {
12960        fn decode(
12961            mut slot: ::fidl_next::Slot<'_, Self>,
12962            decoder: &mut ___D,
12963            _: (),
12964        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
12965            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
12966            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
12967                1 => {
12968                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
12969                        raw,
12970                        decoder,
12971                        (256, ()),
12972                    )?
12973                }
12974
12975                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
12976                    raw,
12977                    decoder,
12978                    (),
12979                )?,
12980
12981                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
12982            }
12983
12984            Ok(())
12985        }
12986    }
12987
12988    impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
12989        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
12990            match self.raw.ordinal() {
12991                1 => unsafe {
12992                    self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
12993                },
12994                2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::EmptyStruct>().fmt(f) },
12995                _ => unsafe { ::core::hint::unreachable_unchecked() },
12996            }
12997        }
12998    }
12999
13000    impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
13001        type Natural = crate::natural::SelinuxContext;
13002    }
13003
13004    /// The wire type corresponding to [`MutableNodeAttributes`].
13005    #[repr(C)]
13006    pub struct MutableNodeAttributes<'de> {
13007        pub(crate) table: ::fidl_next::wire::Table<'de>,
13008    }
13009
13010    impl<'de> Drop for MutableNodeAttributes<'de> {
13011        fn drop(&mut self) {
13012            let _ = self
13013                .table
13014                .get(1)
13015                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13016
13017            let _ = self
13018                .table
13019                .get(2)
13020                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13021
13022            let _ = self
13023                .table
13024                .get(3)
13025                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13026
13027            let _ = self
13028                .table
13029                .get(4)
13030                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13031
13032            let _ = self
13033                .table
13034                .get(5)
13035                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint32>() });
13036
13037            let _ = self
13038                .table
13039                .get(6)
13040                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13041
13042            let _ = self
13043                .table
13044                .get(7)
13045                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13046
13047            let _ = self.table.get(8).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
13048
13049            let _ = self.table.get(9).map(|envelope| unsafe {
13050                envelope.read_unchecked::<crate::wire::SelinuxContext<'de>>()
13051            });
13052
13053            let _ =
13054                self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<[u8; 16]>() });
13055        }
13056    }
13057
13058    impl ::fidl_next::Constrained for MutableNodeAttributes<'_> {
13059        type Constraint = ();
13060
13061        fn validate(
13062            _: ::fidl_next::Slot<'_, Self>,
13063            _: Self::Constraint,
13064        ) -> Result<(), ::fidl_next::ValidationError> {
13065            Ok(())
13066        }
13067    }
13068
13069    unsafe impl ::fidl_next::Wire for MutableNodeAttributes<'static> {
13070        type Narrowed<'de> = MutableNodeAttributes<'de>;
13071
13072        #[inline]
13073        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13074            ::fidl_next::munge!(let Self { table } = out);
13075            ::fidl_next::wire::Table::zero_padding(table);
13076        }
13077    }
13078
13079    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for MutableNodeAttributes<'de>
13080    where
13081        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13082    {
13083        fn decode(
13084            slot: ::fidl_next::Slot<'_, Self>,
13085            decoder: &mut ___D,
13086            _: (),
13087        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13088            ::fidl_next::munge!(let Self { table } = slot);
13089
13090            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13091                match ordinal {
13092                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13093
13094                    1 => {
13095                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13096                            slot.as_mut(),
13097                            decoder,
13098                            (),
13099                        )?;
13100
13101                        Ok(())
13102                    }
13103
13104                    2 => {
13105                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13106                            slot.as_mut(),
13107                            decoder,
13108                            (),
13109                        )?;
13110
13111                        Ok(())
13112                    }
13113
13114                    3 => {
13115                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13116                            slot.as_mut(),
13117                            decoder,
13118                            (),
13119                        )?;
13120
13121                        Ok(())
13122                    }
13123
13124                    4 => {
13125                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13126                            slot.as_mut(),
13127                            decoder,
13128                            (),
13129                        )?;
13130
13131                        Ok(())
13132                    }
13133
13134                    5 => {
13135                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint32>(
13136                            slot.as_mut(),
13137                            decoder,
13138                            (),
13139                        )?;
13140
13141                        Ok(())
13142                    }
13143
13144                    6 => {
13145                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13146                            slot.as_mut(),
13147                            decoder,
13148                            (),
13149                        )?;
13150
13151                        Ok(())
13152                    }
13153
13154                    7 => {
13155                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13156                            slot.as_mut(),
13157                            decoder,
13158                            (),
13159                        )?;
13160
13161                        Ok(())
13162                    }
13163
13164                    8 => {
13165                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
13166                            slot.as_mut(),
13167                            decoder,
13168                            (),
13169                        )?;
13170
13171                        Ok(())
13172                    }
13173
13174                    9 => {
13175                        ::fidl_next::wire::Envelope::decode_as::<
13176                            ___D,
13177                            crate::wire::SelinuxContext<'de>,
13178                        >(slot.as_mut(), decoder, ())?;
13179
13180                        Ok(())
13181                    }
13182
13183                    10 => {
13184                        ::fidl_next::wire::Envelope::decode_as::<___D, [u8; 16]>(
13185                            slot.as_mut(),
13186                            decoder,
13187                            (),
13188                        )?;
13189
13190                        Ok(())
13191                    }
13192
13193                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13194                }
13195            })
13196        }
13197    }
13198
13199    impl<'de> MutableNodeAttributes<'de> {
13200        pub fn creation_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13201            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13202        }
13203
13204        pub fn take_creation_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13205            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13206        }
13207
13208        pub fn modification_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13209            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13210        }
13211
13212        pub fn take_modification_time(
13213            &mut self,
13214        ) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13215            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13216        }
13217
13218        pub fn mode(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13219            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
13220        }
13221
13222        pub fn take_mode(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13223            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
13224        }
13225
13226        pub fn uid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13227            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
13228        }
13229
13230        pub fn take_uid(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13231            unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
13232        }
13233
13234        pub fn gid(&self) -> ::core::option::Option<&::fidl_next::wire::Uint32> {
13235            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
13236        }
13237
13238        pub fn take_gid(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint32> {
13239            unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
13240        }
13241
13242        pub fn rdev(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13243            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
13244        }
13245
13246        pub fn take_rdev(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13247            unsafe { Some(self.table.get_mut(6)?.take_unchecked()) }
13248        }
13249
13250        pub fn access_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13251            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
13252        }
13253
13254        pub fn take_access_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13255            unsafe { Some(self.table.get_mut(7)?.take_unchecked()) }
13256        }
13257
13258        pub fn casefold(&self) -> ::core::option::Option<&bool> {
13259            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
13260        }
13261
13262        pub fn take_casefold(&mut self) -> ::core::option::Option<bool> {
13263            unsafe { Some(self.table.get_mut(8)?.take_unchecked()) }
13264        }
13265
13266        pub fn selinux_context(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
13267            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
13268        }
13269
13270        pub fn take_selinux_context(
13271            &mut self,
13272        ) -> ::core::option::Option<crate::wire::SelinuxContext<'de>> {
13273            unsafe { Some(self.table.get_mut(9)?.take_unchecked()) }
13274        }
13275
13276        pub fn wrapping_key_id(&self) -> ::core::option::Option<&[u8; 16]> {
13277            unsafe { Some(self.table.get(10)?.deref_unchecked()) }
13278        }
13279
13280        pub fn take_wrapping_key_id(&mut self) -> ::core::option::Option<[u8; 16]> {
13281            unsafe { Some(self.table.get_mut(10)?.take_unchecked()) }
13282        }
13283    }
13284
13285    impl<'de> ::core::fmt::Debug for MutableNodeAttributes<'de> {
13286        fn fmt(
13287            &self,
13288            f: &mut ::core::fmt::Formatter<'_>,
13289        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13290            f.debug_struct("MutableNodeAttributes")
13291                .field("creation_time", &self.creation_time())
13292                .field("modification_time", &self.modification_time())
13293                .field("mode", &self.mode())
13294                .field("uid", &self.uid())
13295                .field("gid", &self.gid())
13296                .field("rdev", &self.rdev())
13297                .field("access_time", &self.access_time())
13298                .field("casefold", &self.casefold())
13299                .field("selinux_context", &self.selinux_context())
13300                .field("wrapping_key_id", &self.wrapping_key_id())
13301                .finish()
13302        }
13303    }
13304
13305    impl<'de> ::fidl_next::IntoNatural for MutableNodeAttributes<'de> {
13306        type Natural = crate::natural::MutableNodeAttributes;
13307    }
13308
13309    /// The wire type corresponding to [`NodeProtocolKinds`](crate::natural::NodeProtocolKinds).
13310    #[derive(Clone, Copy, Debug)]
13311    #[repr(transparent)]
13312    pub struct NodeProtocolKinds {
13313        pub(crate) value: ::fidl_next::wire::Uint64,
13314    }
13315
13316    impl ::fidl_next::Constrained for NodeProtocolKinds {
13317        type Constraint = ();
13318
13319        fn validate(
13320            _: ::fidl_next::Slot<'_, Self>,
13321            _: Self::Constraint,
13322        ) -> Result<(), ::fidl_next::ValidationError> {
13323            Ok(())
13324        }
13325    }
13326
13327    unsafe impl ::fidl_next::Wire for NodeProtocolKinds {
13328        type Narrowed<'de> = Self;
13329
13330        #[inline]
13331        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13332            // Wire bits have no padding
13333        }
13334    }
13335
13336    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeProtocolKinds
13337    where
13338        ___D: ?Sized,
13339    {
13340        fn decode(
13341            slot: ::fidl_next::Slot<'_, Self>,
13342            _: &mut ___D,
13343            _: (),
13344        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13345            Ok(())
13346        }
13347    }
13348
13349    impl ::core::convert::From<crate::natural::NodeProtocolKinds> for NodeProtocolKinds {
13350        fn from(natural: crate::natural::NodeProtocolKinds) -> Self {
13351            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
13352        }
13353    }
13354
13355    impl ::fidl_next::IntoNatural for NodeProtocolKinds {
13356        type Natural = crate::natural::NodeProtocolKinds;
13357    }
13358
13359    /// The wire type corresponding to [`HashAlgorithm`].
13360    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
13361    #[repr(transparent)]
13362    pub struct HashAlgorithm {
13363        pub(crate) value: u8,
13364    }
13365
13366    impl ::fidl_next::Constrained for HashAlgorithm {
13367        type Constraint = ();
13368
13369        fn validate(
13370            _: ::fidl_next::Slot<'_, Self>,
13371            _: Self::Constraint,
13372        ) -> Result<(), ::fidl_next::ValidationError> {
13373            Ok(())
13374        }
13375    }
13376
13377    unsafe impl ::fidl_next::Wire for HashAlgorithm {
13378        type Narrowed<'de> = Self;
13379
13380        #[inline]
13381        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
13382            // Wire enums have no padding
13383        }
13384    }
13385
13386    impl HashAlgorithm {
13387        pub const SHA256: HashAlgorithm = HashAlgorithm { value: 1 };
13388
13389        pub const SHA512: HashAlgorithm = HashAlgorithm { value: 2 };
13390    }
13391
13392    unsafe impl<___D> ::fidl_next::Decode<___D> for HashAlgorithm
13393    where
13394        ___D: ?Sized,
13395    {
13396        fn decode(
13397            slot: ::fidl_next::Slot<'_, Self>,
13398            _: &mut ___D,
13399            _: (),
13400        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13401            Ok(())
13402        }
13403    }
13404
13405    impl ::core::convert::From<crate::natural::HashAlgorithm> for HashAlgorithm {
13406        fn from(natural: crate::natural::HashAlgorithm) -> Self {
13407            match natural {
13408                crate::natural::HashAlgorithm::Sha256 => HashAlgorithm::SHA256,
13409
13410                crate::natural::HashAlgorithm::Sha512 => HashAlgorithm::SHA512,
13411
13412                crate::natural::HashAlgorithm::UnknownOrdinal_(value) => {
13413                    HashAlgorithm { value: u8::from(value) }
13414                }
13415            }
13416        }
13417    }
13418
13419    impl ::fidl_next::IntoNatural for HashAlgorithm {
13420        type Natural = crate::natural::HashAlgorithm;
13421    }
13422
13423    /// The wire type corresponding to [`VerificationOptions`].
13424    #[repr(C)]
13425    pub struct VerificationOptions<'de> {
13426        pub(crate) table: ::fidl_next::wire::Table<'de>,
13427    }
13428
13429    impl<'de> Drop for VerificationOptions<'de> {
13430        fn drop(&mut self) {
13431            let _ = self
13432                .table
13433                .get(1)
13434                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::HashAlgorithm>() });
13435
13436            let _ = self.table.get(2).map(|envelope| unsafe {
13437                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
13438            });
13439        }
13440    }
13441
13442    impl ::fidl_next::Constrained for VerificationOptions<'_> {
13443        type Constraint = ();
13444
13445        fn validate(
13446            _: ::fidl_next::Slot<'_, Self>,
13447            _: Self::Constraint,
13448        ) -> Result<(), ::fidl_next::ValidationError> {
13449            Ok(())
13450        }
13451    }
13452
13453    unsafe impl ::fidl_next::Wire for VerificationOptions<'static> {
13454        type Narrowed<'de> = VerificationOptions<'de>;
13455
13456        #[inline]
13457        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13458            ::fidl_next::munge!(let Self { table } = out);
13459            ::fidl_next::wire::Table::zero_padding(table);
13460        }
13461    }
13462
13463    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for VerificationOptions<'de>
13464    where
13465        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13466    {
13467        fn decode(
13468            slot: ::fidl_next::Slot<'_, Self>,
13469            decoder: &mut ___D,
13470            _: (),
13471        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13472            ::fidl_next::munge!(let Self { table } = slot);
13473
13474            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13475                match ordinal {
13476                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13477
13478                    1 => {
13479                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::HashAlgorithm>(
13480                            slot.as_mut(),
13481                            decoder,
13482                            (),
13483                        )?;
13484
13485                        Ok(())
13486                    }
13487
13488                    2 => {
13489                        ::fidl_next::wire::Envelope::decode_as::<
13490                            ___D,
13491                            ::fidl_next::wire::Vector<'de, u8>,
13492                        >(slot.as_mut(), decoder, (32, ()))?;
13493
13494                        let value = unsafe {
13495                            slot.deref_unchecked()
13496                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
13497                        };
13498
13499                        if value.len() > 32 {
13500                            return Err(::fidl_next::DecodeError::VectorTooLong {
13501                                size: value.len() as u64,
13502                                limit: 32,
13503                            });
13504                        }
13505
13506                        Ok(())
13507                    }
13508
13509                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13510                }
13511            })
13512        }
13513    }
13514
13515    impl<'de> VerificationOptions<'de> {
13516        pub fn hash_algorithm(&self) -> ::core::option::Option<&crate::wire::HashAlgorithm> {
13517            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13518        }
13519
13520        pub fn take_hash_algorithm(
13521            &mut self,
13522        ) -> ::core::option::Option<crate::wire::HashAlgorithm> {
13523            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13524        }
13525
13526        pub fn salt(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
13527            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13528        }
13529
13530        pub fn take_salt(&mut self) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
13531            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13532        }
13533    }
13534
13535    impl<'de> ::core::fmt::Debug for VerificationOptions<'de> {
13536        fn fmt(
13537            &self,
13538            f: &mut ::core::fmt::Formatter<'_>,
13539        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13540            f.debug_struct("VerificationOptions")
13541                .field("hash_algorithm", &self.hash_algorithm())
13542                .field("salt", &self.salt())
13543                .finish()
13544        }
13545    }
13546
13547    impl<'de> ::fidl_next::IntoNatural for VerificationOptions<'de> {
13548        type Natural = crate::natural::VerificationOptions;
13549    }
13550
13551    /// The wire type corresponding to [`ImmutableNodeAttributes`].
13552    #[repr(C)]
13553    pub struct ImmutableNodeAttributes<'de> {
13554        pub(crate) table: ::fidl_next::wire::Table<'de>,
13555    }
13556
13557    impl<'de> Drop for ImmutableNodeAttributes<'de> {
13558        fn drop(&mut self) {
13559            let _ = self.table.get(1).map(|envelope| unsafe {
13560                envelope.read_unchecked::<crate::wire::NodeProtocolKinds>()
13561            });
13562
13563            let _ = self
13564                .table
13565                .get(2)
13566                .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
13567
13568            let _ = self
13569                .table
13570                .get(3)
13571                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13572
13573            let _ = self
13574                .table
13575                .get(4)
13576                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13577
13578            let _ = self
13579                .table
13580                .get(5)
13581                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13582
13583            let _ = self
13584                .table
13585                .get(6)
13586                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13587
13588            let _ = self
13589                .table
13590                .get(7)
13591                .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
13592
13593            let _ = self.table.get(8).map(|envelope| unsafe {
13594                envelope.read_unchecked::<crate::wire::VerificationOptions<'de>>()
13595            });
13596
13597            let _ = self.table.get(9).map(|envelope| unsafe {
13598                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
13599            });
13600
13601            let _ = self.table.get(10).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
13602        }
13603    }
13604
13605    impl ::fidl_next::Constrained for ImmutableNodeAttributes<'_> {
13606        type Constraint = ();
13607
13608        fn validate(
13609            _: ::fidl_next::Slot<'_, Self>,
13610            _: Self::Constraint,
13611        ) -> Result<(), ::fidl_next::ValidationError> {
13612            Ok(())
13613        }
13614    }
13615
13616    unsafe impl ::fidl_next::Wire for ImmutableNodeAttributes<'static> {
13617        type Narrowed<'de> = ImmutableNodeAttributes<'de>;
13618
13619        #[inline]
13620        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13621            ::fidl_next::munge!(let Self { table } = out);
13622            ::fidl_next::wire::Table::zero_padding(table);
13623        }
13624    }
13625
13626    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ImmutableNodeAttributes<'de>
13627    where
13628        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13629    {
13630        fn decode(
13631            slot: ::fidl_next::Slot<'_, Self>,
13632            decoder: &mut ___D,
13633            _: (),
13634        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13635            ::fidl_next::munge!(let Self { table } = slot);
13636
13637            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13638                match ordinal {
13639                    0 => unsafe { ::core::hint::unreachable_unchecked() },
13640
13641                    1 => {
13642                        ::fidl_next::wire::Envelope::decode_as::<
13643                            ___D,
13644                            crate::wire::NodeProtocolKinds,
13645                        >(slot.as_mut(), decoder, ())?;
13646
13647                        Ok(())
13648                    }
13649
13650                    2 => {
13651                        ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
13652                            slot.as_mut(),
13653                            decoder,
13654                            (),
13655                        )?;
13656
13657                        Ok(())
13658                    }
13659
13660                    3 => {
13661                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13662                            slot.as_mut(),
13663                            decoder,
13664                            (),
13665                        )?;
13666
13667                        Ok(())
13668                    }
13669
13670                    4 => {
13671                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13672                            slot.as_mut(),
13673                            decoder,
13674                            (),
13675                        )?;
13676
13677                        Ok(())
13678                    }
13679
13680                    5 => {
13681                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13682                            slot.as_mut(),
13683                            decoder,
13684                            (),
13685                        )?;
13686
13687                        Ok(())
13688                    }
13689
13690                    6 => {
13691                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13692                            slot.as_mut(),
13693                            decoder,
13694                            (),
13695                        )?;
13696
13697                        Ok(())
13698                    }
13699
13700                    7 => {
13701                        ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
13702                            slot.as_mut(),
13703                            decoder,
13704                            (),
13705                        )?;
13706
13707                        Ok(())
13708                    }
13709
13710                    8 => {
13711                        ::fidl_next::wire::Envelope::decode_as::<
13712                            ___D,
13713                            crate::wire::VerificationOptions<'de>,
13714                        >(slot.as_mut(), decoder, ())?;
13715
13716                        Ok(())
13717                    }
13718
13719                    9 => {
13720                        ::fidl_next::wire::Envelope::decode_as::<
13721                            ___D,
13722                            ::fidl_next::wire::Vector<'de, u8>,
13723                        >(slot.as_mut(), decoder, (64, ()))?;
13724
13725                        let value = unsafe {
13726                            slot.deref_unchecked()
13727                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
13728                        };
13729
13730                        if value.len() > 64 {
13731                            return Err(::fidl_next::DecodeError::VectorTooLong {
13732                                size: value.len() as u64,
13733                                limit: 64,
13734                            });
13735                        }
13736
13737                        Ok(())
13738                    }
13739
13740                    10 => {
13741                        ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
13742                            slot.as_mut(),
13743                            decoder,
13744                            (),
13745                        )?;
13746
13747                        Ok(())
13748                    }
13749
13750                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
13751                }
13752            })
13753        }
13754    }
13755
13756    impl<'de> ImmutableNodeAttributes<'de> {
13757        pub fn protocols(&self) -> ::core::option::Option<&crate::wire::NodeProtocolKinds> {
13758            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
13759        }
13760
13761        pub fn take_protocols(&mut self) -> ::core::option::Option<crate::wire::NodeProtocolKinds> {
13762            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
13763        }
13764
13765        pub fn abilities(&self) -> ::core::option::Option<&crate::wire::Operations> {
13766            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
13767        }
13768
13769        pub fn take_abilities(&mut self) -> ::core::option::Option<crate::wire::Operations> {
13770            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
13771        }
13772
13773        pub fn content_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13774            unsafe { Some(self.table.get(3)?.deref_unchecked()) }
13775        }
13776
13777        pub fn take_content_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13778            unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
13779        }
13780
13781        pub fn storage_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13782            unsafe { Some(self.table.get(4)?.deref_unchecked()) }
13783        }
13784
13785        pub fn take_storage_size(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13786            unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
13787        }
13788
13789        pub fn link_count(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13790            unsafe { Some(self.table.get(5)?.deref_unchecked()) }
13791        }
13792
13793        pub fn take_link_count(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13794            unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
13795        }
13796
13797        pub fn id(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13798            unsafe { Some(self.table.get(6)?.deref_unchecked()) }
13799        }
13800
13801        pub fn take_id(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13802            unsafe { Some(self.table.get_mut(6)?.take_unchecked()) }
13803        }
13804
13805        pub fn change_time(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
13806            unsafe { Some(self.table.get(7)?.deref_unchecked()) }
13807        }
13808
13809        pub fn take_change_time(&mut self) -> ::core::option::Option<::fidl_next::wire::Uint64> {
13810            unsafe { Some(self.table.get_mut(7)?.take_unchecked()) }
13811        }
13812
13813        pub fn options(&self) -> ::core::option::Option<&crate::wire::VerificationOptions<'de>> {
13814            unsafe { Some(self.table.get(8)?.deref_unchecked()) }
13815        }
13816
13817        pub fn take_options(
13818            &mut self,
13819        ) -> ::core::option::Option<crate::wire::VerificationOptions<'de>> {
13820            unsafe { Some(self.table.get_mut(8)?.take_unchecked()) }
13821        }
13822
13823        pub fn root_hash(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
13824            unsafe { Some(self.table.get(9)?.deref_unchecked()) }
13825        }
13826
13827        pub fn take_root_hash(
13828            &mut self,
13829        ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
13830            unsafe { Some(self.table.get_mut(9)?.take_unchecked()) }
13831        }
13832
13833        pub fn verity_enabled(&self) -> ::core::option::Option<&bool> {
13834            unsafe { Some(self.table.get(10)?.deref_unchecked()) }
13835        }
13836
13837        pub fn take_verity_enabled(&mut self) -> ::core::option::Option<bool> {
13838            unsafe { Some(self.table.get_mut(10)?.take_unchecked()) }
13839        }
13840    }
13841
13842    impl<'de> ::core::fmt::Debug for ImmutableNodeAttributes<'de> {
13843        fn fmt(
13844            &self,
13845            f: &mut ::core::fmt::Formatter<'_>,
13846        ) -> ::core::result::Result<(), ::core::fmt::Error> {
13847            f.debug_struct("ImmutableNodeAttributes")
13848                .field("protocols", &self.protocols())
13849                .field("abilities", &self.abilities())
13850                .field("content_size", &self.content_size())
13851                .field("storage_size", &self.storage_size())
13852                .field("link_count", &self.link_count())
13853                .field("id", &self.id())
13854                .field("change_time", &self.change_time())
13855                .field("options", &self.options())
13856                .field("root_hash", &self.root_hash())
13857                .field("verity_enabled", &self.verity_enabled())
13858                .finish()
13859        }
13860    }
13861
13862    impl<'de> ::fidl_next::IntoNatural for ImmutableNodeAttributes<'de> {
13863        type Natural = crate::natural::ImmutableNodeAttributes;
13864    }
13865
13866    /// The wire type corresponding to [`NodeAttributes2`].
13867    #[derive(Debug)]
13868    #[repr(C)]
13869    pub struct NodeAttributes2<'de> {
13870        pub mutable_attributes: crate::wire::MutableNodeAttributes<'de>,
13871
13872        pub immutable_attributes: crate::wire::ImmutableNodeAttributes<'de>,
13873    }
13874
13875    static_assertions::const_assert_eq!(std::mem::size_of::<NodeAttributes2<'_>>(), 32);
13876    static_assertions::const_assert_eq!(std::mem::align_of::<NodeAttributes2<'_>>(), 8);
13877
13878    static_assertions::const_assert_eq!(
13879        std::mem::offset_of!(NodeAttributes2<'_>, mutable_attributes),
13880        0
13881    );
13882
13883    static_assertions::const_assert_eq!(
13884        std::mem::offset_of!(NodeAttributes2<'_>, immutable_attributes),
13885        16
13886    );
13887
13888    impl ::fidl_next::Constrained for NodeAttributes2<'_> {
13889        type Constraint = ();
13890
13891        fn validate(
13892            _: ::fidl_next::Slot<'_, Self>,
13893            _: Self::Constraint,
13894        ) -> Result<(), ::fidl_next::ValidationError> {
13895            Ok(())
13896        }
13897    }
13898
13899    unsafe impl ::fidl_next::Wire for NodeAttributes2<'static> {
13900        type Narrowed<'de> = NodeAttributes2<'de>;
13901
13902        #[inline]
13903        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
13904            ::fidl_next::munge! {
13905                let Self {
13906                    mutable_attributes,
13907                    immutable_attributes,
13908
13909                } = &mut *out_;
13910            }
13911
13912            ::fidl_next::Wire::zero_padding(mutable_attributes);
13913
13914            ::fidl_next::Wire::zero_padding(immutable_attributes);
13915        }
13916    }
13917
13918    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeAttributes2<'de>
13919    where
13920        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
13921        ___D: ::fidl_next::Decoder<'de>,
13922    {
13923        fn decode(
13924            slot_: ::fidl_next::Slot<'_, Self>,
13925            decoder_: &mut ___D,
13926            _: (),
13927        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13928            ::fidl_next::munge! {
13929                let Self {
13930                    mut mutable_attributes,
13931                    mut immutable_attributes,
13932
13933                } = slot_;
13934            }
13935
13936            let _field = mutable_attributes.as_mut();
13937
13938            ::fidl_next::Decode::decode(mutable_attributes.as_mut(), decoder_, ())?;
13939
13940            let _field = immutable_attributes.as_mut();
13941
13942            ::fidl_next::Decode::decode(immutable_attributes.as_mut(), decoder_, ())?;
13943
13944            Ok(())
13945        }
13946    }
13947
13948    impl<'de> ::fidl_next::IntoNatural for NodeAttributes2<'de> {
13949        type Natural = crate::natural::NodeAttributes2;
13950    }
13951
13952    /// The wire type corresponding to [`NodeInfo`].
13953    #[repr(C)]
13954    pub struct NodeInfo<'de> {
13955        pub(crate) table: ::fidl_next::wire::Table<'de>,
13956    }
13957
13958    impl<'de> Drop for NodeInfo<'de> {
13959        fn drop(&mut self) {
13960            let _ = self.table.get(1).map(|envelope| unsafe {
13961                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
13962            });
13963        }
13964    }
13965
13966    impl ::fidl_next::Constrained for NodeInfo<'_> {
13967        type Constraint = ();
13968
13969        fn validate(
13970            _: ::fidl_next::Slot<'_, Self>,
13971            _: Self::Constraint,
13972        ) -> Result<(), ::fidl_next::ValidationError> {
13973            Ok(())
13974        }
13975    }
13976
13977    unsafe impl ::fidl_next::Wire for NodeInfo<'static> {
13978        type Narrowed<'de> = NodeInfo<'de>;
13979
13980        #[inline]
13981        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
13982            ::fidl_next::munge!(let Self { table } = out);
13983            ::fidl_next::wire::Table::zero_padding(table);
13984        }
13985    }
13986
13987    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfo<'de>
13988    where
13989        ___D: ::fidl_next::Decoder<'de> + ?Sized,
13990    {
13991        fn decode(
13992            slot: ::fidl_next::Slot<'_, Self>,
13993            decoder: &mut ___D,
13994            _: (),
13995        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
13996            ::fidl_next::munge!(let Self { table } = slot);
13997
13998            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
13999                match ordinal {
14000                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14001
14002                    1 => {
14003                        ::fidl_next::wire::Envelope::decode_as::<
14004                            ___D,
14005                            crate::wire::NodeAttributes2<'de>,
14006                        >(slot.as_mut(), decoder, ())?;
14007
14008                        Ok(())
14009                    }
14010
14011                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14012                }
14013            })
14014        }
14015    }
14016
14017    impl<'de> NodeInfo<'de> {
14018        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14019            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14020        }
14021
14022        pub fn take_attributes(
14023            &mut self,
14024        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14025            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14026        }
14027    }
14028
14029    impl<'de> ::core::fmt::Debug for NodeInfo<'de> {
14030        fn fmt(
14031            &self,
14032            f: &mut ::core::fmt::Formatter<'_>,
14033        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14034            f.debug_struct("NodeInfo").field("attributes", &self.attributes()).finish()
14035        }
14036    }
14037
14038    impl<'de> ::fidl_next::IntoNatural for NodeInfo<'de> {
14039        type Natural = crate::natural::NodeInfo;
14040    }
14041
14042    /// The wire type corresponding to [`DirectoryInfo`].
14043    #[repr(C)]
14044    pub struct DirectoryInfo<'de> {
14045        pub(crate) table: ::fidl_next::wire::Table<'de>,
14046    }
14047
14048    impl<'de> Drop for DirectoryInfo<'de> {
14049        fn drop(&mut self) {
14050            let _ = self.table.get(1).map(|envelope| unsafe {
14051                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
14052            });
14053        }
14054    }
14055
14056    impl ::fidl_next::Constrained for DirectoryInfo<'_> {
14057        type Constraint = ();
14058
14059        fn validate(
14060            _: ::fidl_next::Slot<'_, Self>,
14061            _: Self::Constraint,
14062        ) -> Result<(), ::fidl_next::ValidationError> {
14063            Ok(())
14064        }
14065    }
14066
14067    unsafe impl ::fidl_next::Wire for DirectoryInfo<'static> {
14068        type Narrowed<'de> = DirectoryInfo<'de>;
14069
14070        #[inline]
14071        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14072            ::fidl_next::munge!(let Self { table } = out);
14073            ::fidl_next::wire::Table::zero_padding(table);
14074        }
14075    }
14076
14077    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryInfo<'de>
14078    where
14079        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14080    {
14081        fn decode(
14082            slot: ::fidl_next::Slot<'_, Self>,
14083            decoder: &mut ___D,
14084            _: (),
14085        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14086            ::fidl_next::munge!(let Self { table } = slot);
14087
14088            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14089                match ordinal {
14090                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14091
14092                    1 => {
14093                        ::fidl_next::wire::Envelope::decode_as::<
14094                            ___D,
14095                            crate::wire::NodeAttributes2<'de>,
14096                        >(slot.as_mut(), decoder, ())?;
14097
14098                        Ok(())
14099                    }
14100
14101                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14102                }
14103            })
14104        }
14105    }
14106
14107    impl<'de> DirectoryInfo<'de> {
14108        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14109            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14110        }
14111
14112        pub fn take_attributes(
14113            &mut self,
14114        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14115            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14116        }
14117    }
14118
14119    impl<'de> ::core::fmt::Debug for DirectoryInfo<'de> {
14120        fn fmt(
14121            &self,
14122            f: &mut ::core::fmt::Formatter<'_>,
14123        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14124            f.debug_struct("DirectoryInfo").field("attributes", &self.attributes()).finish()
14125        }
14126    }
14127
14128    impl<'de> ::fidl_next::IntoNatural for DirectoryInfo<'de> {
14129        type Natural = crate::natural::DirectoryInfo;
14130    }
14131
14132    /// The wire type corresponding to [`SymlinkInfo`].
14133    #[repr(C)]
14134    pub struct SymlinkInfo<'de> {
14135        pub(crate) table: ::fidl_next::wire::Table<'de>,
14136    }
14137
14138    impl<'de> Drop for SymlinkInfo<'de> {
14139        fn drop(&mut self) {
14140            let _ = self.table.get(1).map(|envelope| unsafe {
14141                envelope.read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
14142            });
14143
14144            let _ = self.table.get(2).map(|envelope| unsafe {
14145                envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
14146            });
14147        }
14148    }
14149
14150    impl ::fidl_next::Constrained for SymlinkInfo<'_> {
14151        type Constraint = ();
14152
14153        fn validate(
14154            _: ::fidl_next::Slot<'_, Self>,
14155            _: Self::Constraint,
14156        ) -> Result<(), ::fidl_next::ValidationError> {
14157            Ok(())
14158        }
14159    }
14160
14161    unsafe impl ::fidl_next::Wire for SymlinkInfo<'static> {
14162        type Narrowed<'de> = SymlinkInfo<'de>;
14163
14164        #[inline]
14165        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14166            ::fidl_next::munge!(let Self { table } = out);
14167            ::fidl_next::wire::Table::zero_padding(table);
14168        }
14169    }
14170
14171    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkInfo<'de>
14172    where
14173        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14174    {
14175        fn decode(
14176            slot: ::fidl_next::Slot<'_, Self>,
14177            decoder: &mut ___D,
14178            _: (),
14179        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14180            ::fidl_next::munge!(let Self { table } = slot);
14181
14182            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14183                match ordinal {
14184                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14185
14186                    1 => {
14187                        ::fidl_next::wire::Envelope::decode_as::<
14188                            ___D,
14189                            ::fidl_next::wire::Vector<'de, u8>,
14190                        >(slot.as_mut(), decoder, (4095, ()))?;
14191
14192                        let value = unsafe {
14193                            slot.deref_unchecked()
14194                                .deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
14195                        };
14196
14197                        if value.len() > 4095 {
14198                            return Err(::fidl_next::DecodeError::VectorTooLong {
14199                                size: value.len() as u64,
14200                                limit: 4095,
14201                            });
14202                        }
14203
14204                        Ok(())
14205                    }
14206
14207                    2 => {
14208                        ::fidl_next::wire::Envelope::decode_as::<
14209                            ___D,
14210                            crate::wire::NodeAttributes2<'de>,
14211                        >(slot.as_mut(), decoder, ())?;
14212
14213                        Ok(())
14214                    }
14215
14216                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14217                }
14218            })
14219        }
14220    }
14221
14222    impl<'de> SymlinkInfo<'de> {
14223        pub fn target(&self) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, u8>> {
14224            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14225        }
14226
14227        pub fn take_target(
14228            &mut self,
14229        ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, u8>> {
14230            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14231        }
14232
14233        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
14234            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14235        }
14236
14237        pub fn take_attributes(
14238            &mut self,
14239        ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
14240            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14241        }
14242    }
14243
14244    impl<'de> ::core::fmt::Debug for SymlinkInfo<'de> {
14245        fn fmt(
14246            &self,
14247            f: &mut ::core::fmt::Formatter<'_>,
14248        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14249            f.debug_struct("SymlinkInfo")
14250                .field("target", &self.target())
14251                .field("attributes", &self.attributes())
14252                .finish()
14253        }
14254    }
14255
14256    impl<'de> ::fidl_next::IntoNatural for SymlinkInfo<'de> {
14257        type Natural = crate::natural::SymlinkInfo;
14258    }
14259
14260    /// The wire type corresponding to [`NodeAttributesQuery`](crate::natural::NodeAttributesQuery).
14261    #[derive(Clone, Copy, Debug)]
14262    #[repr(transparent)]
14263    pub struct NodeAttributesQuery {
14264        pub(crate) value: ::fidl_next::wire::Uint64,
14265    }
14266
14267    impl ::fidl_next::Constrained for NodeAttributesQuery {
14268        type Constraint = ();
14269
14270        fn validate(
14271            _: ::fidl_next::Slot<'_, Self>,
14272            _: Self::Constraint,
14273        ) -> Result<(), ::fidl_next::ValidationError> {
14274            Ok(())
14275        }
14276    }
14277
14278    unsafe impl ::fidl_next::Wire for NodeAttributesQuery {
14279        type Narrowed<'de> = Self;
14280
14281        #[inline]
14282        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14283            // Wire bits have no padding
14284        }
14285    }
14286
14287    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeAttributesQuery
14288    where
14289        ___D: ?Sized,
14290    {
14291        fn decode(
14292            slot: ::fidl_next::Slot<'_, Self>,
14293            _: &mut ___D,
14294            _: (),
14295        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14296            Ok(())
14297        }
14298    }
14299
14300    impl ::core::convert::From<crate::natural::NodeAttributesQuery> for NodeAttributesQuery {
14301        fn from(natural: crate::natural::NodeAttributesQuery) -> Self {
14302            Self { value: ::fidl_next::wire::Uint64::from(natural.bits()) }
14303        }
14304    }
14305
14306    impl ::fidl_next::IntoNatural for NodeAttributesQuery {
14307        type Natural = crate::natural::NodeAttributesQuery;
14308    }
14309
14310    /// The wire type corresponding to [`NodeGetAttributesRequest`].
14311    #[derive(Clone, Debug)]
14312    #[repr(C)]
14313    pub struct NodeGetAttributesRequest {
14314        pub query: crate::wire::NodeAttributesQuery,
14315    }
14316
14317    static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetAttributesRequest>(), 8);
14318    static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetAttributesRequest>(), 8);
14319
14320    static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetAttributesRequest, query), 0);
14321
14322    impl ::fidl_next::Constrained for NodeGetAttributesRequest {
14323        type Constraint = ();
14324
14325        fn validate(
14326            _: ::fidl_next::Slot<'_, Self>,
14327            _: Self::Constraint,
14328        ) -> Result<(), ::fidl_next::ValidationError> {
14329            Ok(())
14330        }
14331    }
14332
14333    unsafe impl ::fidl_next::Wire for NodeGetAttributesRequest {
14334        type Narrowed<'de> = NodeGetAttributesRequest;
14335
14336        #[inline]
14337        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14338            ::fidl_next::munge! {
14339                let Self {
14340                    query,
14341
14342                } = &mut *out_;
14343            }
14344
14345            ::fidl_next::Wire::zero_padding(query);
14346        }
14347    }
14348
14349    unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetAttributesRequest
14350    where
14351        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14352    {
14353        fn decode(
14354            slot_: ::fidl_next::Slot<'_, Self>,
14355            decoder_: &mut ___D,
14356            _: (),
14357        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14358            ::fidl_next::munge! {
14359                let Self {
14360                    mut query,
14361
14362                } = slot_;
14363            }
14364
14365            let _field = query.as_mut();
14366
14367            ::fidl_next::Decode::decode(query.as_mut(), decoder_, ())?;
14368
14369            Ok(())
14370        }
14371    }
14372
14373    impl ::fidl_next::IntoNatural for NodeGetAttributesRequest {
14374        type Natural = crate::natural::NodeGetAttributesRequest;
14375    }
14376
14377    /// The wire type corresponding to [`Options`].
14378    #[repr(C)]
14379    pub struct Options<'de> {
14380        pub(crate) table: ::fidl_next::wire::Table<'de>,
14381    }
14382
14383    impl<'de> Drop for Options<'de> {
14384        fn drop(&mut self) {
14385            let _ = self.table.get(1).map(|envelope| unsafe {
14386                envelope.read_unchecked::<crate::wire::NodeAttributesQuery>()
14387            });
14388
14389            let _ = self.table.get(2).map(|envelope| unsafe {
14390                envelope.read_unchecked::<crate::wire::MutableNodeAttributes<'de>>()
14391            });
14392        }
14393    }
14394
14395    impl ::fidl_next::Constrained for Options<'_> {
14396        type Constraint = ();
14397
14398        fn validate(
14399            _: ::fidl_next::Slot<'_, Self>,
14400            _: Self::Constraint,
14401        ) -> Result<(), ::fidl_next::ValidationError> {
14402            Ok(())
14403        }
14404    }
14405
14406    unsafe impl ::fidl_next::Wire for Options<'static> {
14407        type Narrowed<'de> = Options<'de>;
14408
14409        #[inline]
14410        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
14411            ::fidl_next::munge!(let Self { table } = out);
14412            ::fidl_next::wire::Table::zero_padding(table);
14413        }
14414    }
14415
14416    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Options<'de>
14417    where
14418        ___D: ::fidl_next::Decoder<'de> + ?Sized,
14419    {
14420        fn decode(
14421            slot: ::fidl_next::Slot<'_, Self>,
14422            decoder: &mut ___D,
14423            _: (),
14424        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14425            ::fidl_next::munge!(let Self { table } = slot);
14426
14427            ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
14428                match ordinal {
14429                    0 => unsafe { ::core::hint::unreachable_unchecked() },
14430
14431                    1 => {
14432                        ::fidl_next::wire::Envelope::decode_as::<
14433                            ___D,
14434                            crate::wire::NodeAttributesQuery,
14435                        >(slot.as_mut(), decoder, ())?;
14436
14437                        Ok(())
14438                    }
14439
14440                    2 => {
14441                        ::fidl_next::wire::Envelope::decode_as::<
14442                            ___D,
14443                            crate::wire::MutableNodeAttributes<'de>,
14444                        >(slot.as_mut(), decoder, ())?;
14445
14446                        Ok(())
14447                    }
14448
14449                    _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
14450                }
14451            })
14452        }
14453    }
14454
14455    impl<'de> Options<'de> {
14456        pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributesQuery> {
14457            unsafe { Some(self.table.get(1)?.deref_unchecked()) }
14458        }
14459
14460        pub fn take_attributes(
14461            &mut self,
14462        ) -> ::core::option::Option<crate::wire::NodeAttributesQuery> {
14463            unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
14464        }
14465
14466        pub fn create_attributes(
14467            &self,
14468        ) -> ::core::option::Option<&crate::wire::MutableNodeAttributes<'de>> {
14469            unsafe { Some(self.table.get(2)?.deref_unchecked()) }
14470        }
14471
14472        pub fn take_create_attributes(
14473            &mut self,
14474        ) -> ::core::option::Option<crate::wire::MutableNodeAttributes<'de>> {
14475            unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
14476        }
14477    }
14478
14479    impl<'de> ::core::fmt::Debug for Options<'de> {
14480        fn fmt(
14481            &self,
14482            f: &mut ::core::fmt::Formatter<'_>,
14483        ) -> ::core::result::Result<(), ::core::fmt::Error> {
14484            f.debug_struct("Options")
14485                .field("attributes", &self.attributes())
14486                .field("create_attributes", &self.create_attributes())
14487                .finish()
14488        }
14489    }
14490
14491    impl<'de> ::fidl_next::IntoNatural for Options<'de> {
14492        type Natural = crate::natural::Options;
14493    }
14494
14495    /// The wire type corresponding to [`DirectoryObject`].
14496    pub type DirectoryObject = ::fidl_next::wire::Unit;
14497
14498    /// The wire type corresponding to [`DirentType`].
14499    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
14500    #[repr(transparent)]
14501    pub struct DirentType {
14502        pub(crate) value: u8,
14503    }
14504
14505    impl ::fidl_next::Constrained for DirentType {
14506        type Constraint = ();
14507
14508        fn validate(
14509            _: ::fidl_next::Slot<'_, Self>,
14510            _: Self::Constraint,
14511        ) -> Result<(), ::fidl_next::ValidationError> {
14512            Ok(())
14513        }
14514    }
14515
14516    unsafe impl ::fidl_next::Wire for DirentType {
14517        type Narrowed<'de> = Self;
14518
14519        #[inline]
14520        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
14521            // Wire enums have no padding
14522        }
14523    }
14524
14525    impl DirentType {
14526        pub const UNKNOWN: DirentType = DirentType { value: 0 };
14527
14528        pub const DIRECTORY: DirentType = DirentType { value: 4 };
14529
14530        pub const BLOCK_DEVICE: DirentType = DirentType { value: 6 };
14531
14532        pub const FILE: DirentType = DirentType { value: 8 };
14533
14534        pub const SYMLINK: DirentType = DirentType { value: 10 };
14535
14536        pub const SERVICE: DirentType = DirentType { value: 16 };
14537    }
14538
14539    unsafe impl<___D> ::fidl_next::Decode<___D> for DirentType
14540    where
14541        ___D: ?Sized,
14542    {
14543        fn decode(
14544            slot: ::fidl_next::Slot<'_, Self>,
14545            _: &mut ___D,
14546            _: (),
14547        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14548            Ok(())
14549        }
14550    }
14551
14552    impl ::core::convert::From<crate::natural::DirentType> for DirentType {
14553        fn from(natural: crate::natural::DirentType) -> Self {
14554            match natural {
14555                crate::natural::DirentType::Unknown => DirentType::UNKNOWN,
14556
14557                crate::natural::DirentType::Directory => DirentType::DIRECTORY,
14558
14559                crate::natural::DirentType::BlockDevice => DirentType::BLOCK_DEVICE,
14560
14561                crate::natural::DirentType::File => DirentType::FILE,
14562
14563                crate::natural::DirentType::Symlink => DirentType::SYMLINK,
14564
14565                crate::natural::DirentType::Service => DirentType::SERVICE,
14566
14567                crate::natural::DirentType::UnknownOrdinal_(value) => {
14568                    DirentType { value: u8::from(value) }
14569                }
14570            }
14571        }
14572    }
14573
14574    impl ::fidl_next::IntoNatural for DirentType {
14575        type Natural = crate::natural::DirentType;
14576    }
14577
14578    /// The wire type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
14579    #[derive(Debug)]
14580    #[repr(C)]
14581    pub struct ExtendedAttributeIteratorGetNextResponse<'de> {
14582        pub attributes: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::Vector<'de, u8>>,
14583
14584        pub last: bool,
14585    }
14586
14587    static_assertions::const_assert_eq!(
14588        std::mem::size_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
14589        24
14590    );
14591    static_assertions::const_assert_eq!(
14592        std::mem::align_of::<ExtendedAttributeIteratorGetNextResponse<'_>>(),
14593        8
14594    );
14595
14596    static_assertions::const_assert_eq!(
14597        std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, attributes),
14598        0
14599    );
14600
14601    static_assertions::const_assert_eq!(
14602        std::mem::offset_of!(ExtendedAttributeIteratorGetNextResponse<'_>, last),
14603        16
14604    );
14605
14606    impl ::fidl_next::Constrained for ExtendedAttributeIteratorGetNextResponse<'_> {
14607        type Constraint = ();
14608
14609        fn validate(
14610            _: ::fidl_next::Slot<'_, Self>,
14611            _: Self::Constraint,
14612        ) -> Result<(), ::fidl_next::ValidationError> {
14613            Ok(())
14614        }
14615    }
14616
14617    unsafe impl ::fidl_next::Wire for ExtendedAttributeIteratorGetNextResponse<'static> {
14618        type Narrowed<'de> = ExtendedAttributeIteratorGetNextResponse<'de>;
14619
14620        #[inline]
14621        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14622            ::fidl_next::munge! {
14623                let Self {
14624                    attributes,
14625                    last,
14626
14627                } = &mut *out_;
14628            }
14629
14630            ::fidl_next::Wire::zero_padding(attributes);
14631
14632            ::fidl_next::Wire::zero_padding(last);
14633
14634            unsafe {
14635                out_.as_mut_ptr().cast::<u8>().add(17).write_bytes(0, 7);
14636            }
14637        }
14638    }
14639
14640    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeIteratorGetNextResponse<'de>
14641    where
14642        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14643        ___D: ::fidl_next::Decoder<'de>,
14644    {
14645        fn decode(
14646            slot_: ::fidl_next::Slot<'_, Self>,
14647            decoder_: &mut ___D,
14648            _: (),
14649        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14650            if slot_.as_bytes()[17..24] != [0u8; 7] {
14651                return Err(::fidl_next::DecodeError::InvalidPadding);
14652            }
14653
14654            ::fidl_next::munge! {
14655                let Self {
14656                    mut attributes,
14657                    mut last,
14658
14659                } = slot_;
14660            }
14661
14662            let _field = attributes.as_mut();
14663            ::fidl_next::Constrained::validate(_field, (128, (255, ())))?;
14664            ::fidl_next::Decode::decode(attributes.as_mut(), decoder_, (128, (255, ())))?;
14665
14666            let attributes = unsafe { attributes.deref_unchecked() };
14667
14668            if attributes.len() > 128 {
14669                return Err(::fidl_next::DecodeError::VectorTooLong {
14670                    size: attributes.len() as u64,
14671                    limit: 128,
14672                });
14673            }
14674
14675            let _field = last.as_mut();
14676
14677            ::fidl_next::Decode::decode(last.as_mut(), decoder_, ())?;
14678
14679            Ok(())
14680        }
14681    }
14682
14683    impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeIteratorGetNextResponse<'de> {
14684        type Natural = crate::natural::ExtendedAttributeIteratorGetNextResponse;
14685    }
14686
14687    /// The wire type corresponding to [`ReadableReadRequest`].
14688    #[derive(Clone, Debug)]
14689    #[repr(C)]
14690    pub struct ReadableReadRequest {
14691        pub count: ::fidl_next::wire::Uint64,
14692    }
14693
14694    static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadRequest>(), 8);
14695    static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadRequest>(), 8);
14696
14697    static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadRequest, count), 0);
14698
14699    impl ::fidl_next::Constrained for ReadableReadRequest {
14700        type Constraint = ();
14701
14702        fn validate(
14703            _: ::fidl_next::Slot<'_, Self>,
14704            _: Self::Constraint,
14705        ) -> Result<(), ::fidl_next::ValidationError> {
14706            Ok(())
14707        }
14708    }
14709
14710    unsafe impl ::fidl_next::Wire for ReadableReadRequest {
14711        type Narrowed<'de> = ReadableReadRequest;
14712
14713        #[inline]
14714        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14715            ::fidl_next::munge! {
14716                let Self {
14717                    count,
14718
14719                } = &mut *out_;
14720            }
14721
14722            ::fidl_next::Wire::zero_padding(count);
14723        }
14724    }
14725
14726    unsafe impl<___D> ::fidl_next::Decode<___D> for ReadableReadRequest
14727    where
14728        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14729    {
14730        fn decode(
14731            slot_: ::fidl_next::Slot<'_, Self>,
14732            decoder_: &mut ___D,
14733            _: (),
14734        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14735            ::fidl_next::munge! {
14736                let Self {
14737                    mut count,
14738
14739                } = slot_;
14740            }
14741
14742            let _field = count.as_mut();
14743
14744            ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
14745
14746            Ok(())
14747        }
14748    }
14749
14750    impl ::fidl_next::IntoNatural for ReadableReadRequest {
14751        type Natural = crate::natural::ReadableReadRequest;
14752    }
14753
14754    /// The wire type corresponding to [`Transfer`](crate::natural::Transfer).
14755    pub type Transfer<'de> = ::fidl_next::wire::Vector<'de, u8>;
14756
14757    /// The wire type corresponding to [`ReadableReadResponse`].
14758    #[derive(Debug)]
14759    #[repr(C)]
14760    pub struct ReadableReadResponse<'de> {
14761        pub data: ::fidl_next::wire::Vector<'de, u8>,
14762    }
14763
14764    static_assertions::const_assert_eq!(std::mem::size_of::<ReadableReadResponse<'_>>(), 16);
14765    static_assertions::const_assert_eq!(std::mem::align_of::<ReadableReadResponse<'_>>(), 8);
14766
14767    static_assertions::const_assert_eq!(std::mem::offset_of!(ReadableReadResponse<'_>, data), 0);
14768
14769    impl ::fidl_next::Constrained for ReadableReadResponse<'_> {
14770        type Constraint = ();
14771
14772        fn validate(
14773            _: ::fidl_next::Slot<'_, Self>,
14774            _: Self::Constraint,
14775        ) -> Result<(), ::fidl_next::ValidationError> {
14776            Ok(())
14777        }
14778    }
14779
14780    unsafe impl ::fidl_next::Wire for ReadableReadResponse<'static> {
14781        type Narrowed<'de> = ReadableReadResponse<'de>;
14782
14783        #[inline]
14784        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14785            ::fidl_next::munge! {
14786                let Self {
14787                    data,
14788
14789                } = &mut *out_;
14790            }
14791
14792            ::fidl_next::Wire::zero_padding(data);
14793        }
14794    }
14795
14796    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ReadableReadResponse<'de>
14797    where
14798        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14799        ___D: ::fidl_next::Decoder<'de>,
14800    {
14801        fn decode(
14802            slot_: ::fidl_next::Slot<'_, Self>,
14803            decoder_: &mut ___D,
14804            _: (),
14805        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14806            ::fidl_next::munge! {
14807                let Self {
14808                    mut data,
14809
14810                } = slot_;
14811            }
14812
14813            let _field = data.as_mut();
14814            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
14815            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
14816
14817            let data = unsafe { data.deref_unchecked() };
14818
14819            if data.len() > 8192 {
14820                return Err(::fidl_next::DecodeError::VectorTooLong {
14821                    size: data.len() as u64,
14822                    limit: 8192,
14823                });
14824            }
14825
14826            Ok(())
14827        }
14828    }
14829
14830    impl<'de> ::fidl_next::IntoNatural for ReadableReadResponse<'de> {
14831        type Natural = crate::natural::ReadableReadResponse;
14832    }
14833
14834    /// The wire type corresponding to [`WritableWriteRequest`].
14835    #[derive(Debug)]
14836    #[repr(C)]
14837    pub struct WritableWriteRequest<'de> {
14838        pub data: ::fidl_next::wire::Vector<'de, u8>,
14839    }
14840
14841    static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteRequest<'_>>(), 16);
14842    static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteRequest<'_>>(), 8);
14843
14844    static_assertions::const_assert_eq!(std::mem::offset_of!(WritableWriteRequest<'_>, data), 0);
14845
14846    impl ::fidl_next::Constrained for WritableWriteRequest<'_> {
14847        type Constraint = ();
14848
14849        fn validate(
14850            _: ::fidl_next::Slot<'_, Self>,
14851            _: Self::Constraint,
14852        ) -> Result<(), ::fidl_next::ValidationError> {
14853            Ok(())
14854        }
14855    }
14856
14857    unsafe impl ::fidl_next::Wire for WritableWriteRequest<'static> {
14858        type Narrowed<'de> = WritableWriteRequest<'de>;
14859
14860        #[inline]
14861        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14862            ::fidl_next::munge! {
14863                let Self {
14864                    data,
14865
14866                } = &mut *out_;
14867            }
14868
14869            ::fidl_next::Wire::zero_padding(data);
14870        }
14871    }
14872
14873    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for WritableWriteRequest<'de>
14874    where
14875        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14876        ___D: ::fidl_next::Decoder<'de>,
14877    {
14878        fn decode(
14879            slot_: ::fidl_next::Slot<'_, Self>,
14880            decoder_: &mut ___D,
14881            _: (),
14882        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14883            ::fidl_next::munge! {
14884                let Self {
14885                    mut data,
14886
14887                } = slot_;
14888            }
14889
14890            let _field = data.as_mut();
14891            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
14892            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
14893
14894            let data = unsafe { data.deref_unchecked() };
14895
14896            if data.len() > 8192 {
14897                return Err(::fidl_next::DecodeError::VectorTooLong {
14898                    size: data.len() as u64,
14899                    limit: 8192,
14900                });
14901            }
14902
14903            Ok(())
14904        }
14905    }
14906
14907    impl<'de> ::fidl_next::IntoNatural for WritableWriteRequest<'de> {
14908        type Natural = crate::natural::WritableWriteRequest;
14909    }
14910
14911    /// The wire type corresponding to [`WritableWriteResponse`].
14912    #[derive(Clone, Debug)]
14913    #[repr(C)]
14914    pub struct WritableWriteResponse {
14915        pub actual_count: ::fidl_next::wire::Uint64,
14916    }
14917
14918    static_assertions::const_assert_eq!(std::mem::size_of::<WritableWriteResponse>(), 8);
14919    static_assertions::const_assert_eq!(std::mem::align_of::<WritableWriteResponse>(), 8);
14920
14921    static_assertions::const_assert_eq!(
14922        std::mem::offset_of!(WritableWriteResponse, actual_count),
14923        0
14924    );
14925
14926    impl ::fidl_next::Constrained for WritableWriteResponse {
14927        type Constraint = ();
14928
14929        fn validate(
14930            _: ::fidl_next::Slot<'_, Self>,
14931            _: Self::Constraint,
14932        ) -> Result<(), ::fidl_next::ValidationError> {
14933            Ok(())
14934        }
14935    }
14936
14937    unsafe impl ::fidl_next::Wire for WritableWriteResponse {
14938        type Narrowed<'de> = WritableWriteResponse;
14939
14940        #[inline]
14941        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
14942            ::fidl_next::munge! {
14943                let Self {
14944                    actual_count,
14945
14946                } = &mut *out_;
14947            }
14948
14949            ::fidl_next::Wire::zero_padding(actual_count);
14950        }
14951    }
14952
14953    unsafe impl<___D> ::fidl_next::Decode<___D> for WritableWriteResponse
14954    where
14955        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
14956    {
14957        fn decode(
14958            slot_: ::fidl_next::Slot<'_, Self>,
14959            decoder_: &mut ___D,
14960            _: (),
14961        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
14962            ::fidl_next::munge! {
14963                let Self {
14964                    mut actual_count,
14965
14966                } = slot_;
14967            }
14968
14969            let _field = actual_count.as_mut();
14970
14971            ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
14972
14973            Ok(())
14974        }
14975    }
14976
14977    impl ::fidl_next::IntoNatural for WritableWriteResponse {
14978        type Natural = crate::natural::WritableWriteResponse;
14979    }
14980
14981    /// The wire type corresponding to [`FileSeekRequest`].
14982    #[derive(Clone, Debug)]
14983    #[repr(C)]
14984    pub struct FileSeekRequest {
14985        pub origin: crate::wire::SeekOrigin,
14986
14987        pub offset: ::fidl_next::wire::Int64,
14988    }
14989
14990    static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekRequest>(), 16);
14991    static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekRequest>(), 8);
14992
14993    static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, origin), 0);
14994
14995    static_assertions::const_assert_eq!(std::mem::offset_of!(FileSeekRequest, offset), 8);
14996
14997    impl ::fidl_next::Constrained for FileSeekRequest {
14998        type Constraint = ();
14999
15000        fn validate(
15001            _: ::fidl_next::Slot<'_, Self>,
15002            _: Self::Constraint,
15003        ) -> Result<(), ::fidl_next::ValidationError> {
15004            Ok(())
15005        }
15006    }
15007
15008    unsafe impl ::fidl_next::Wire for FileSeekRequest {
15009        type Narrowed<'de> = FileSeekRequest;
15010
15011        #[inline]
15012        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15013            ::fidl_next::munge! {
15014                let Self {
15015                    origin,
15016                    offset,
15017
15018                } = &mut *out_;
15019            }
15020
15021            ::fidl_next::Wire::zero_padding(origin);
15022
15023            ::fidl_next::Wire::zero_padding(offset);
15024
15025            unsafe {
15026                out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
15027            }
15028        }
15029    }
15030
15031    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekRequest
15032    where
15033        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15034    {
15035        fn decode(
15036            slot_: ::fidl_next::Slot<'_, Self>,
15037            decoder_: &mut ___D,
15038            _: (),
15039        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15040            if slot_.as_bytes()[4..8] != [0u8; 4] {
15041                return Err(::fidl_next::DecodeError::InvalidPadding);
15042            }
15043
15044            ::fidl_next::munge! {
15045                let Self {
15046                    mut origin,
15047                    mut offset,
15048
15049                } = slot_;
15050            }
15051
15052            let _field = origin.as_mut();
15053
15054            ::fidl_next::Decode::decode(origin.as_mut(), decoder_, ())?;
15055
15056            let _field = offset.as_mut();
15057
15058            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15059
15060            Ok(())
15061        }
15062    }
15063
15064    impl ::fidl_next::IntoNatural for FileSeekRequest {
15065        type Natural = crate::natural::FileSeekRequest;
15066    }
15067
15068    /// The wire type corresponding to [`FileSeekResponse`].
15069    #[derive(Clone, Debug)]
15070    #[repr(C)]
15071    pub struct FileSeekResponse {
15072        pub offset_from_start: ::fidl_next::wire::Uint64,
15073    }
15074
15075    static_assertions::const_assert_eq!(std::mem::size_of::<FileSeekResponse>(), 8);
15076    static_assertions::const_assert_eq!(std::mem::align_of::<FileSeekResponse>(), 8);
15077
15078    static_assertions::const_assert_eq!(
15079        std::mem::offset_of!(FileSeekResponse, offset_from_start),
15080        0
15081    );
15082
15083    impl ::fidl_next::Constrained for FileSeekResponse {
15084        type Constraint = ();
15085
15086        fn validate(
15087            _: ::fidl_next::Slot<'_, Self>,
15088            _: Self::Constraint,
15089        ) -> Result<(), ::fidl_next::ValidationError> {
15090            Ok(())
15091        }
15092    }
15093
15094    unsafe impl ::fidl_next::Wire for FileSeekResponse {
15095        type Narrowed<'de> = FileSeekResponse;
15096
15097        #[inline]
15098        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15099            ::fidl_next::munge! {
15100                let Self {
15101                    offset_from_start,
15102
15103                } = &mut *out_;
15104            }
15105
15106            ::fidl_next::Wire::zero_padding(offset_from_start);
15107        }
15108    }
15109
15110    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSeekResponse
15111    where
15112        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15113    {
15114        fn decode(
15115            slot_: ::fidl_next::Slot<'_, Self>,
15116            decoder_: &mut ___D,
15117            _: (),
15118        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15119            ::fidl_next::munge! {
15120                let Self {
15121                    mut offset_from_start,
15122
15123                } = slot_;
15124            }
15125
15126            let _field = offset_from_start.as_mut();
15127
15128            ::fidl_next::Decode::decode(offset_from_start.as_mut(), decoder_, ())?;
15129
15130            Ok(())
15131        }
15132    }
15133
15134    impl ::fidl_next::IntoNatural for FileSeekResponse {
15135        type Natural = crate::natural::FileSeekResponse;
15136    }
15137
15138    /// The wire type corresponding to [`FileReadAtRequest`].
15139    #[derive(Clone, Debug)]
15140    #[repr(C)]
15141    pub struct FileReadAtRequest {
15142        pub count: ::fidl_next::wire::Uint64,
15143
15144        pub offset: ::fidl_next::wire::Uint64,
15145    }
15146
15147    static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtRequest>(), 16);
15148    static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtRequest>(), 8);
15149
15150    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, count), 0);
15151
15152    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtRequest, offset), 8);
15153
15154    impl ::fidl_next::Constrained for FileReadAtRequest {
15155        type Constraint = ();
15156
15157        fn validate(
15158            _: ::fidl_next::Slot<'_, Self>,
15159            _: Self::Constraint,
15160        ) -> Result<(), ::fidl_next::ValidationError> {
15161            Ok(())
15162        }
15163    }
15164
15165    unsafe impl ::fidl_next::Wire for FileReadAtRequest {
15166        type Narrowed<'de> = FileReadAtRequest;
15167
15168        #[inline]
15169        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15170            ::fidl_next::munge! {
15171                let Self {
15172                    count,
15173                    offset,
15174
15175                } = &mut *out_;
15176            }
15177
15178            ::fidl_next::Wire::zero_padding(count);
15179
15180            ::fidl_next::Wire::zero_padding(offset);
15181        }
15182    }
15183
15184    unsafe impl<___D> ::fidl_next::Decode<___D> for FileReadAtRequest
15185    where
15186        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15187    {
15188        fn decode(
15189            slot_: ::fidl_next::Slot<'_, Self>,
15190            decoder_: &mut ___D,
15191            _: (),
15192        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15193            ::fidl_next::munge! {
15194                let Self {
15195                    mut count,
15196                    mut offset,
15197
15198                } = slot_;
15199            }
15200
15201            let _field = count.as_mut();
15202
15203            ::fidl_next::Decode::decode(count.as_mut(), decoder_, ())?;
15204
15205            let _field = offset.as_mut();
15206
15207            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15208
15209            Ok(())
15210        }
15211    }
15212
15213    impl ::fidl_next::IntoNatural for FileReadAtRequest {
15214        type Natural = crate::natural::FileReadAtRequest;
15215    }
15216
15217    /// The wire type corresponding to [`FileReadAtResponse`].
15218    #[derive(Debug)]
15219    #[repr(C)]
15220    pub struct FileReadAtResponse<'de> {
15221        pub data: ::fidl_next::wire::Vector<'de, u8>,
15222    }
15223
15224    static_assertions::const_assert_eq!(std::mem::size_of::<FileReadAtResponse<'_>>(), 16);
15225    static_assertions::const_assert_eq!(std::mem::align_of::<FileReadAtResponse<'_>>(), 8);
15226
15227    static_assertions::const_assert_eq!(std::mem::offset_of!(FileReadAtResponse<'_>, data), 0);
15228
15229    impl ::fidl_next::Constrained for FileReadAtResponse<'_> {
15230        type Constraint = ();
15231
15232        fn validate(
15233            _: ::fidl_next::Slot<'_, Self>,
15234            _: Self::Constraint,
15235        ) -> Result<(), ::fidl_next::ValidationError> {
15236            Ok(())
15237        }
15238    }
15239
15240    unsafe impl ::fidl_next::Wire for FileReadAtResponse<'static> {
15241        type Narrowed<'de> = FileReadAtResponse<'de>;
15242
15243        #[inline]
15244        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15245            ::fidl_next::munge! {
15246                let Self {
15247                    data,
15248
15249                } = &mut *out_;
15250            }
15251
15252            ::fidl_next::Wire::zero_padding(data);
15253        }
15254    }
15255
15256    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileReadAtResponse<'de>
15257    where
15258        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15259        ___D: ::fidl_next::Decoder<'de>,
15260    {
15261        fn decode(
15262            slot_: ::fidl_next::Slot<'_, Self>,
15263            decoder_: &mut ___D,
15264            _: (),
15265        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15266            ::fidl_next::munge! {
15267                let Self {
15268                    mut data,
15269
15270                } = slot_;
15271            }
15272
15273            let _field = data.as_mut();
15274            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
15275            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
15276
15277            let data = unsafe { data.deref_unchecked() };
15278
15279            if data.len() > 8192 {
15280                return Err(::fidl_next::DecodeError::VectorTooLong {
15281                    size: data.len() as u64,
15282                    limit: 8192,
15283                });
15284            }
15285
15286            Ok(())
15287        }
15288    }
15289
15290    impl<'de> ::fidl_next::IntoNatural for FileReadAtResponse<'de> {
15291        type Natural = crate::natural::FileReadAtResponse;
15292    }
15293
15294    /// The wire type corresponding to [`FileWriteAtRequest`].
15295    #[derive(Debug)]
15296    #[repr(C)]
15297    pub struct FileWriteAtRequest<'de> {
15298        pub data: ::fidl_next::wire::Vector<'de, u8>,
15299
15300        pub offset: ::fidl_next::wire::Uint64,
15301    }
15302
15303    static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtRequest<'_>>(), 24);
15304    static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtRequest<'_>>(), 8);
15305
15306    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, data), 0);
15307
15308    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtRequest<'_>, offset), 16);
15309
15310    impl ::fidl_next::Constrained for FileWriteAtRequest<'_> {
15311        type Constraint = ();
15312
15313        fn validate(
15314            _: ::fidl_next::Slot<'_, Self>,
15315            _: Self::Constraint,
15316        ) -> Result<(), ::fidl_next::ValidationError> {
15317            Ok(())
15318        }
15319    }
15320
15321    unsafe impl ::fidl_next::Wire for FileWriteAtRequest<'static> {
15322        type Narrowed<'de> = FileWriteAtRequest<'de>;
15323
15324        #[inline]
15325        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15326            ::fidl_next::munge! {
15327                let Self {
15328                    data,
15329                    offset,
15330
15331                } = &mut *out_;
15332            }
15333
15334            ::fidl_next::Wire::zero_padding(data);
15335
15336            ::fidl_next::Wire::zero_padding(offset);
15337        }
15338    }
15339
15340    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileWriteAtRequest<'de>
15341    where
15342        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15343        ___D: ::fidl_next::Decoder<'de>,
15344    {
15345        fn decode(
15346            slot_: ::fidl_next::Slot<'_, Self>,
15347            decoder_: &mut ___D,
15348            _: (),
15349        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15350            ::fidl_next::munge! {
15351                let Self {
15352                    mut data,
15353                    mut offset,
15354
15355                } = slot_;
15356            }
15357
15358            let _field = data.as_mut();
15359            ::fidl_next::Constrained::validate(_field, (8192, ()))?;
15360            ::fidl_next::Decode::decode(data.as_mut(), decoder_, (8192, ()))?;
15361
15362            let data = unsafe { data.deref_unchecked() };
15363
15364            if data.len() > 8192 {
15365                return Err(::fidl_next::DecodeError::VectorTooLong {
15366                    size: data.len() as u64,
15367                    limit: 8192,
15368                });
15369            }
15370
15371            let _field = offset.as_mut();
15372
15373            ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
15374
15375            Ok(())
15376        }
15377    }
15378
15379    impl<'de> ::fidl_next::IntoNatural for FileWriteAtRequest<'de> {
15380        type Natural = crate::natural::FileWriteAtRequest;
15381    }
15382
15383    /// The wire type corresponding to [`FileWriteAtResponse`].
15384    #[derive(Clone, Debug)]
15385    #[repr(C)]
15386    pub struct FileWriteAtResponse {
15387        pub actual_count: ::fidl_next::wire::Uint64,
15388    }
15389
15390    static_assertions::const_assert_eq!(std::mem::size_of::<FileWriteAtResponse>(), 8);
15391    static_assertions::const_assert_eq!(std::mem::align_of::<FileWriteAtResponse>(), 8);
15392
15393    static_assertions::const_assert_eq!(std::mem::offset_of!(FileWriteAtResponse, actual_count), 0);
15394
15395    impl ::fidl_next::Constrained for FileWriteAtResponse {
15396        type Constraint = ();
15397
15398        fn validate(
15399            _: ::fidl_next::Slot<'_, Self>,
15400            _: Self::Constraint,
15401        ) -> Result<(), ::fidl_next::ValidationError> {
15402            Ok(())
15403        }
15404    }
15405
15406    unsafe impl ::fidl_next::Wire for FileWriteAtResponse {
15407        type Narrowed<'de> = FileWriteAtResponse;
15408
15409        #[inline]
15410        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15411            ::fidl_next::munge! {
15412                let Self {
15413                    actual_count,
15414
15415                } = &mut *out_;
15416            }
15417
15418            ::fidl_next::Wire::zero_padding(actual_count);
15419        }
15420    }
15421
15422    unsafe impl<___D> ::fidl_next::Decode<___D> for FileWriteAtResponse
15423    where
15424        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15425    {
15426        fn decode(
15427            slot_: ::fidl_next::Slot<'_, Self>,
15428            decoder_: &mut ___D,
15429            _: (),
15430        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15431            ::fidl_next::munge! {
15432                let Self {
15433                    mut actual_count,
15434
15435                } = slot_;
15436            }
15437
15438            let _field = actual_count.as_mut();
15439
15440            ::fidl_next::Decode::decode(actual_count.as_mut(), decoder_, ())?;
15441
15442            Ok(())
15443        }
15444    }
15445
15446    impl ::fidl_next::IntoNatural for FileWriteAtResponse {
15447        type Natural = crate::natural::FileWriteAtResponse;
15448    }
15449
15450    /// The wire type corresponding to [`FileResizeRequest`].
15451    #[derive(Clone, Debug)]
15452    #[repr(C)]
15453    pub struct FileResizeRequest {
15454        pub length: ::fidl_next::wire::Uint64,
15455    }
15456
15457    static_assertions::const_assert_eq!(std::mem::size_of::<FileResizeRequest>(), 8);
15458    static_assertions::const_assert_eq!(std::mem::align_of::<FileResizeRequest>(), 8);
15459
15460    static_assertions::const_assert_eq!(std::mem::offset_of!(FileResizeRequest, length), 0);
15461
15462    impl ::fidl_next::Constrained for FileResizeRequest {
15463        type Constraint = ();
15464
15465        fn validate(
15466            _: ::fidl_next::Slot<'_, Self>,
15467            _: Self::Constraint,
15468        ) -> Result<(), ::fidl_next::ValidationError> {
15469            Ok(())
15470        }
15471    }
15472
15473    unsafe impl ::fidl_next::Wire for FileResizeRequest {
15474        type Narrowed<'de> = FileResizeRequest;
15475
15476        #[inline]
15477        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15478            ::fidl_next::munge! {
15479                let Self {
15480                    length,
15481
15482                } = &mut *out_;
15483            }
15484
15485            ::fidl_next::Wire::zero_padding(length);
15486        }
15487    }
15488
15489    unsafe impl<___D> ::fidl_next::Decode<___D> for FileResizeRequest
15490    where
15491        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15492    {
15493        fn decode(
15494            slot_: ::fidl_next::Slot<'_, Self>,
15495            decoder_: &mut ___D,
15496            _: (),
15497        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15498            ::fidl_next::munge! {
15499                let Self {
15500                    mut length,
15501
15502                } = slot_;
15503            }
15504
15505            let _field = length.as_mut();
15506
15507            ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
15508
15509            Ok(())
15510        }
15511    }
15512
15513    impl ::fidl_next::IntoNatural for FileResizeRequest {
15514        type Natural = crate::natural::FileResizeRequest;
15515    }
15516
15517    /// The wire type corresponding to [`FileResizeResponse`].
15518    pub type FileResizeResponse = ::fidl_next::wire::Unit;
15519
15520    /// The wire type corresponding to [`VmoFlags`](crate::natural::VmoFlags).
15521    #[derive(Clone, Copy, Debug)]
15522    #[repr(transparent)]
15523    pub struct VmoFlags {
15524        pub(crate) value: ::fidl_next::wire::Uint32,
15525    }
15526
15527    impl ::fidl_next::Constrained for VmoFlags {
15528        type Constraint = ();
15529
15530        fn validate(
15531            _: ::fidl_next::Slot<'_, Self>,
15532            _: Self::Constraint,
15533        ) -> Result<(), ::fidl_next::ValidationError> {
15534            Ok(())
15535        }
15536    }
15537
15538    unsafe impl ::fidl_next::Wire for VmoFlags {
15539        type Narrowed<'de> = Self;
15540
15541        #[inline]
15542        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
15543            // Wire bits have no padding
15544        }
15545    }
15546
15547    unsafe impl<___D> ::fidl_next::Decode<___D> for VmoFlags
15548    where
15549        ___D: ?Sized,
15550    {
15551        fn decode(
15552            slot: ::fidl_next::Slot<'_, Self>,
15553            _: &mut ___D,
15554            _: (),
15555        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15556            ::fidl_next::munge!(let Self { value } = slot);
15557            let set = u32::from(*value);
15558            if set & !crate::natural::VmoFlags::all().bits() != 0 {
15559                return Err(::fidl_next::DecodeError::InvalidBits {
15560                    expected: crate::natural::VmoFlags::all().bits() as usize,
15561                    actual: set as usize,
15562                });
15563            }
15564
15565            Ok(())
15566        }
15567    }
15568
15569    impl ::core::convert::From<crate::natural::VmoFlags> for VmoFlags {
15570        fn from(natural: crate::natural::VmoFlags) -> Self {
15571            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
15572        }
15573    }
15574
15575    impl ::fidl_next::IntoNatural for VmoFlags {
15576        type Natural = crate::natural::VmoFlags;
15577    }
15578
15579    /// The wire type corresponding to [`FileGetBackingMemoryRequest`].
15580    #[derive(Clone, Debug)]
15581    #[repr(C)]
15582    pub struct FileGetBackingMemoryRequest {
15583        pub flags: crate::wire::VmoFlags,
15584    }
15585
15586    static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryRequest>(), 4);
15587    static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryRequest>(), 4);
15588
15589    static_assertions::const_assert_eq!(
15590        std::mem::offset_of!(FileGetBackingMemoryRequest, flags),
15591        0
15592    );
15593
15594    impl ::fidl_next::Constrained for FileGetBackingMemoryRequest {
15595        type Constraint = ();
15596
15597        fn validate(
15598            _: ::fidl_next::Slot<'_, Self>,
15599            _: Self::Constraint,
15600        ) -> Result<(), ::fidl_next::ValidationError> {
15601            Ok(())
15602        }
15603    }
15604
15605    unsafe impl ::fidl_next::Wire for FileGetBackingMemoryRequest {
15606        type Narrowed<'de> = FileGetBackingMemoryRequest;
15607
15608        #[inline]
15609        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15610            ::fidl_next::munge! {
15611                let Self {
15612                    flags,
15613
15614                } = &mut *out_;
15615            }
15616
15617            ::fidl_next::Wire::zero_padding(flags);
15618        }
15619    }
15620
15621    unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryRequest
15622    where
15623        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15624    {
15625        fn decode(
15626            slot_: ::fidl_next::Slot<'_, Self>,
15627            decoder_: &mut ___D,
15628            _: (),
15629        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15630            ::fidl_next::munge! {
15631                let Self {
15632                    mut flags,
15633
15634                } = slot_;
15635            }
15636
15637            let _field = flags.as_mut();
15638
15639            ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
15640
15641            Ok(())
15642        }
15643    }
15644
15645    impl ::fidl_next::IntoNatural for FileGetBackingMemoryRequest {
15646        type Natural = crate::natural::FileGetBackingMemoryRequest;
15647    }
15648
15649    /// The wire type corresponding to [`LinkableLinkIntoResponse`].
15650    pub type LinkableLinkIntoResponse = ::fidl_next::wire::Unit;
15651
15652    /// The wire type corresponding to [`FileAllocateResponse`].
15653    pub type FileAllocateResponse = ::fidl_next::wire::Unit;
15654
15655    /// The wire type corresponding to [`FileEnableVerityResponse`].
15656    pub type FileEnableVerityResponse = ::fidl_next::wire::Unit;
15657
15658    /// The wire type corresponding to [`FileSignal`](crate::natural::FileSignal).
15659    #[derive(Clone, Copy, Debug)]
15660    #[repr(transparent)]
15661    pub struct FileSignal {
15662        pub(crate) value: ::fidl_next::wire::Uint32,
15663    }
15664
15665    impl ::fidl_next::Constrained for FileSignal {
15666        type Constraint = ();
15667
15668        fn validate(
15669            _: ::fidl_next::Slot<'_, Self>,
15670            _: Self::Constraint,
15671        ) -> Result<(), ::fidl_next::ValidationError> {
15672            Ok(())
15673        }
15674    }
15675
15676    unsafe impl ::fidl_next::Wire for FileSignal {
15677        type Narrowed<'de> = Self;
15678
15679        #[inline]
15680        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
15681            // Wire bits have no padding
15682        }
15683    }
15684
15685    unsafe impl<___D> ::fidl_next::Decode<___D> for FileSignal
15686    where
15687        ___D: ?Sized,
15688    {
15689        fn decode(
15690            slot: ::fidl_next::Slot<'_, Self>,
15691            _: &mut ___D,
15692            _: (),
15693        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15694            ::fidl_next::munge!(let Self { value } = slot);
15695            let set = u32::from(*value);
15696            if set & !crate::natural::FileSignal::all().bits() != 0 {
15697                return Err(::fidl_next::DecodeError::InvalidBits {
15698                    expected: crate::natural::FileSignal::all().bits() as usize,
15699                    actual: set as usize,
15700                });
15701            }
15702
15703            Ok(())
15704        }
15705    }
15706
15707    impl ::core::convert::From<crate::natural::FileSignal> for FileSignal {
15708        fn from(natural: crate::natural::FileSignal) -> Self {
15709            Self { value: ::fidl_next::wire::Uint32::from(natural.bits()) }
15710        }
15711    }
15712
15713    impl ::fidl_next::IntoNatural for FileSignal {
15714        type Natural = crate::natural::FileSignal;
15715    }
15716
15717    /// The wire type corresponding to [`FilesystemInfo`].
15718    #[derive(Clone, Debug)]
15719    #[repr(C)]
15720    pub struct FilesystemInfo {
15721        pub total_bytes: ::fidl_next::wire::Uint64,
15722
15723        pub used_bytes: ::fidl_next::wire::Uint64,
15724
15725        pub total_nodes: ::fidl_next::wire::Uint64,
15726
15727        pub used_nodes: ::fidl_next::wire::Uint64,
15728
15729        pub free_shared_pool_bytes: ::fidl_next::wire::Uint64,
15730
15731        pub fs_id: ::fidl_next::wire::Uint64,
15732
15733        pub block_size: ::fidl_next::wire::Uint32,
15734
15735        pub max_filename_size: ::fidl_next::wire::Uint32,
15736
15737        pub fs_type: ::fidl_next::wire::Uint32,
15738
15739        pub padding: ::fidl_next::wire::Uint32,
15740
15741        pub name: [i8; 32],
15742    }
15743
15744    static_assertions::const_assert_eq!(std::mem::size_of::<FilesystemInfo>(), 96);
15745    static_assertions::const_assert_eq!(std::mem::align_of::<FilesystemInfo>(), 8);
15746
15747    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_bytes), 0);
15748
15749    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_bytes), 8);
15750
15751    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, total_nodes), 16);
15752
15753    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, used_nodes), 24);
15754
15755    static_assertions::const_assert_eq!(
15756        std::mem::offset_of!(FilesystemInfo, free_shared_pool_bytes),
15757        32
15758    );
15759
15760    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_id), 40);
15761
15762    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, block_size), 48);
15763
15764    static_assertions::const_assert_eq!(
15765        std::mem::offset_of!(FilesystemInfo, max_filename_size),
15766        52
15767    );
15768
15769    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, fs_type), 56);
15770
15771    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, padding), 60);
15772
15773    static_assertions::const_assert_eq!(std::mem::offset_of!(FilesystemInfo, name), 64);
15774
15775    impl ::fidl_next::Constrained for FilesystemInfo {
15776        type Constraint = ();
15777
15778        fn validate(
15779            _: ::fidl_next::Slot<'_, Self>,
15780            _: Self::Constraint,
15781        ) -> Result<(), ::fidl_next::ValidationError> {
15782            Ok(())
15783        }
15784    }
15785
15786    unsafe impl ::fidl_next::Wire for FilesystemInfo {
15787        type Narrowed<'de> = FilesystemInfo;
15788
15789        #[inline]
15790        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15791            ::fidl_next::munge! {
15792                let Self {
15793                    total_bytes,
15794                    used_bytes,
15795                    total_nodes,
15796                    used_nodes,
15797                    free_shared_pool_bytes,
15798                    fs_id,
15799                    block_size,
15800                    max_filename_size,
15801                    fs_type,
15802                    padding,
15803                    name,
15804
15805                } = &mut *out_;
15806            }
15807
15808            ::fidl_next::Wire::zero_padding(total_bytes);
15809
15810            ::fidl_next::Wire::zero_padding(used_bytes);
15811
15812            ::fidl_next::Wire::zero_padding(total_nodes);
15813
15814            ::fidl_next::Wire::zero_padding(used_nodes);
15815
15816            ::fidl_next::Wire::zero_padding(free_shared_pool_bytes);
15817
15818            ::fidl_next::Wire::zero_padding(fs_id);
15819
15820            ::fidl_next::Wire::zero_padding(block_size);
15821
15822            ::fidl_next::Wire::zero_padding(max_filename_size);
15823
15824            ::fidl_next::Wire::zero_padding(fs_type);
15825
15826            ::fidl_next::Wire::zero_padding(padding);
15827
15828            ::fidl_next::Wire::zero_padding(name);
15829        }
15830    }
15831
15832    unsafe impl<___D> ::fidl_next::Decode<___D> for FilesystemInfo
15833    where
15834        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15835    {
15836        fn decode(
15837            slot_: ::fidl_next::Slot<'_, Self>,
15838            decoder_: &mut ___D,
15839            _: (),
15840        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15841            ::fidl_next::munge! {
15842                let Self {
15843                    mut total_bytes,
15844                    mut used_bytes,
15845                    mut total_nodes,
15846                    mut used_nodes,
15847                    mut free_shared_pool_bytes,
15848                    mut fs_id,
15849                    mut block_size,
15850                    mut max_filename_size,
15851                    mut fs_type,
15852                    mut padding,
15853                    mut name,
15854
15855                } = slot_;
15856            }
15857
15858            let _field = total_bytes.as_mut();
15859
15860            ::fidl_next::Decode::decode(total_bytes.as_mut(), decoder_, ())?;
15861
15862            let _field = used_bytes.as_mut();
15863
15864            ::fidl_next::Decode::decode(used_bytes.as_mut(), decoder_, ())?;
15865
15866            let _field = total_nodes.as_mut();
15867
15868            ::fidl_next::Decode::decode(total_nodes.as_mut(), decoder_, ())?;
15869
15870            let _field = used_nodes.as_mut();
15871
15872            ::fidl_next::Decode::decode(used_nodes.as_mut(), decoder_, ())?;
15873
15874            let _field = free_shared_pool_bytes.as_mut();
15875
15876            ::fidl_next::Decode::decode(free_shared_pool_bytes.as_mut(), decoder_, ())?;
15877
15878            let _field = fs_id.as_mut();
15879
15880            ::fidl_next::Decode::decode(fs_id.as_mut(), decoder_, ())?;
15881
15882            let _field = block_size.as_mut();
15883
15884            ::fidl_next::Decode::decode(block_size.as_mut(), decoder_, ())?;
15885
15886            let _field = max_filename_size.as_mut();
15887
15888            ::fidl_next::Decode::decode(max_filename_size.as_mut(), decoder_, ())?;
15889
15890            let _field = fs_type.as_mut();
15891
15892            ::fidl_next::Decode::decode(fs_type.as_mut(), decoder_, ())?;
15893
15894            let _field = padding.as_mut();
15895
15896            ::fidl_next::Decode::decode(padding.as_mut(), decoder_, ())?;
15897
15898            let _field = name.as_mut();
15899
15900            ::fidl_next::Decode::decode(name.as_mut(), decoder_, ())?;
15901
15902            Ok(())
15903        }
15904    }
15905
15906    impl ::fidl_next::IntoNatural for FilesystemInfo {
15907        type Natural = crate::natural::FilesystemInfo;
15908    }
15909
15910    /// The wire type corresponding to [`Service`].
15911    pub type Service = ::fidl_next::wire::Unit;
15912
15913    /// The wire type corresponding to [`SymlinkObject`].
15914    #[derive(Debug)]
15915    #[repr(C)]
15916    pub struct SymlinkObject<'de> {
15917        pub target: ::fidl_next::wire::Vector<'de, u8>,
15918    }
15919
15920    static_assertions::const_assert_eq!(std::mem::size_of::<SymlinkObject<'_>>(), 16);
15921    static_assertions::const_assert_eq!(std::mem::align_of::<SymlinkObject<'_>>(), 8);
15922
15923    static_assertions::const_assert_eq!(std::mem::offset_of!(SymlinkObject<'_>, target), 0);
15924
15925    impl ::fidl_next::Constrained for SymlinkObject<'_> {
15926        type Constraint = ();
15927
15928        fn validate(
15929            _: ::fidl_next::Slot<'_, Self>,
15930            _: Self::Constraint,
15931        ) -> Result<(), ::fidl_next::ValidationError> {
15932            Ok(())
15933        }
15934    }
15935
15936    unsafe impl ::fidl_next::Wire for SymlinkObject<'static> {
15937        type Narrowed<'de> = SymlinkObject<'de>;
15938
15939        #[inline]
15940        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
15941            ::fidl_next::munge! {
15942                let Self {
15943                    target,
15944
15945                } = &mut *out_;
15946            }
15947
15948            ::fidl_next::Wire::zero_padding(target);
15949        }
15950    }
15951
15952    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SymlinkObject<'de>
15953    where
15954        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
15955        ___D: ::fidl_next::Decoder<'de>,
15956    {
15957        fn decode(
15958            slot_: ::fidl_next::Slot<'_, Self>,
15959            decoder_: &mut ___D,
15960            _: (),
15961        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
15962            ::fidl_next::munge! {
15963                let Self {
15964                    mut target,
15965
15966                } = slot_;
15967            }
15968
15969            let _field = target.as_mut();
15970            ::fidl_next::Constrained::validate(_field, (4095, ()))?;
15971            ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
15972
15973            let target = unsafe { target.deref_unchecked() };
15974
15975            if target.len() > 4095 {
15976                return Err(::fidl_next::DecodeError::VectorTooLong {
15977                    size: target.len() as u64,
15978                    limit: 4095,
15979                });
15980            }
15981
15982            Ok(())
15983        }
15984    }
15985
15986    impl<'de> ::fidl_next::IntoNatural for SymlinkObject<'de> {
15987        type Natural = crate::natural::SymlinkObject;
15988    }
15989
15990    /// The wire type corresponding to [`WatchEvent`].
15991    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
15992    #[repr(transparent)]
15993    pub struct WatchEvent {
15994        pub(crate) value: u8,
15995    }
15996
15997    impl ::fidl_next::Constrained for WatchEvent {
15998        type Constraint = ();
15999
16000        fn validate(
16001            _: ::fidl_next::Slot<'_, Self>,
16002            _: Self::Constraint,
16003        ) -> Result<(), ::fidl_next::ValidationError> {
16004            Ok(())
16005        }
16006    }
16007
16008    unsafe impl ::fidl_next::Wire for WatchEvent {
16009        type Narrowed<'de> = Self;
16010
16011        #[inline]
16012        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
16013            // Wire enums have no padding
16014        }
16015    }
16016
16017    impl WatchEvent {
16018        pub const DELETED: WatchEvent = WatchEvent { value: 0 };
16019
16020        pub const ADDED: WatchEvent = WatchEvent { value: 1 };
16021
16022        pub const REMOVED: WatchEvent = WatchEvent { value: 2 };
16023
16024        pub const EXISTING: WatchEvent = WatchEvent { value: 3 };
16025
16026        pub const IDLE: WatchEvent = WatchEvent { value: 4 };
16027    }
16028
16029    unsafe impl<___D> ::fidl_next::Decode<___D> for WatchEvent
16030    where
16031        ___D: ?Sized,
16032    {
16033        fn decode(
16034            slot: ::fidl_next::Slot<'_, Self>,
16035            _: &mut ___D,
16036            _: (),
16037        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16038            ::fidl_next::munge!(let Self { value } = slot);
16039
16040            match u8::from(*value) {
16041                0 | 1 | 2 | 3 | 4 => (),
16042                unknown => {
16043                    return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
16044                }
16045            }
16046
16047            Ok(())
16048        }
16049    }
16050
16051    impl ::core::convert::From<crate::natural::WatchEvent> for WatchEvent {
16052        fn from(natural: crate::natural::WatchEvent) -> Self {
16053            match natural {
16054                crate::natural::WatchEvent::Deleted => WatchEvent::DELETED,
16055
16056                crate::natural::WatchEvent::Added => WatchEvent::ADDED,
16057
16058                crate::natural::WatchEvent::Removed => WatchEvent::REMOVED,
16059
16060                crate::natural::WatchEvent::Existing => WatchEvent::EXISTING,
16061
16062                crate::natural::WatchEvent::Idle => WatchEvent::IDLE,
16063            }
16064        }
16065    }
16066
16067    impl ::fidl_next::IntoNatural for WatchEvent {
16068        type Natural = crate::natural::WatchEvent;
16069    }
16070}
16071
16072pub mod wire_optional {
16073
16074    #[repr(transparent)]
16075    pub struct SelinuxContext<'de> {
16076        pub(crate) raw: ::fidl_next::wire::Union,
16077        pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
16078    }
16079
16080    impl ::fidl_next::Constrained for SelinuxContext<'_> {
16081        type Constraint = ();
16082
16083        fn validate(
16084            _: ::fidl_next::Slot<'_, Self>,
16085            _: Self::Constraint,
16086        ) -> Result<(), ::fidl_next::ValidationError> {
16087            Ok(())
16088        }
16089    }
16090
16091    unsafe impl ::fidl_next::Wire for SelinuxContext<'static> {
16092        type Narrowed<'de> = SelinuxContext<'de>;
16093
16094        #[inline]
16095        fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
16096            ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
16097            ::fidl_next::wire::Union::zero_padding(raw);
16098        }
16099    }
16100
16101    impl<'de> SelinuxContext<'de> {
16102        pub fn is_some(&self) -> bool {
16103            self.raw.is_some()
16104        }
16105
16106        pub fn is_none(&self) -> bool {
16107            self.raw.is_none()
16108        }
16109
16110        pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::SelinuxContext<'de>> {
16111            if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
16112        }
16113
16114        pub fn into_option(self) -> ::core::option::Option<crate::wire::SelinuxContext<'de>> {
16115            if self.is_some() {
16116                Some(crate::wire::SelinuxContext {
16117                    raw: self.raw,
16118                    _phantom: ::core::marker::PhantomData,
16119                })
16120            } else {
16121                None
16122            }
16123        }
16124    }
16125
16126    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for SelinuxContext<'de>
16127    where
16128        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
16129        ___D: ::fidl_next::Decoder<'de>,
16130    {
16131        fn decode(
16132            mut slot: ::fidl_next::Slot<'_, Self>,
16133            decoder: &mut ___D,
16134            _: (),
16135        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
16136            ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
16137            match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
16138                1 => {
16139                    ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
16140                        raw,
16141                        decoder,
16142                        (256, ()),
16143                    )?
16144                }
16145
16146                2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::EmptyStruct>(
16147                    raw,
16148                    decoder,
16149                    (),
16150                )?,
16151
16152                0 => ::fidl_next::wire::Union::decode_absent(raw)?,
16153                _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
16154            }
16155
16156            Ok(())
16157        }
16158    }
16159
16160    impl<'de> ::core::fmt::Debug for SelinuxContext<'de> {
16161        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
16162            self.as_ref().fmt(f)
16163        }
16164    }
16165
16166    impl<'de> ::fidl_next::IntoNatural for SelinuxContext<'de> {
16167        type Natural = ::core::option::Option<crate::natural::SelinuxContext>;
16168    }
16169}
16170
16171pub mod generic {
16172
16173    /// The generic type corresponding to [`AdvisoryLockRange`].
16174    pub struct AdvisoryLockRange<T0, T1, T2> {
16175        pub origin: T0,
16176
16177        pub offset: T1,
16178
16179        pub length: T2,
16180    }
16181
16182    unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::AdvisoryLockRange, ___E>
16183        for AdvisoryLockRange<T0, T1, T2>
16184    where
16185        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16186        T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
16187        T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
16188        T2: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
16189    {
16190        #[inline]
16191        fn encode(
16192            self,
16193            encoder_: &mut ___E,
16194            out_: &mut ::core::mem::MaybeUninit<crate::wire::AdvisoryLockRange>,
16195            _: (),
16196        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16197            ::fidl_next::munge! {
16198                let crate::wire::AdvisoryLockRange {
16199                    origin,
16200                    offset,
16201                    length,
16202
16203                } = out_;
16204            }
16205
16206            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
16207
16208            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
16209
16210            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
16211
16212            Ok(())
16213        }
16214    }
16215
16216    /// The generic type corresponding to [`AdvisoryLockingAdvisoryLockRequest`].
16217    pub struct AdvisoryLockingAdvisoryLockRequest<T0> {
16218        pub request: T0,
16219    }
16220
16221    unsafe impl<___E, T0>
16222        ::fidl_next::Encode<crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>, ___E>
16223        for AdvisoryLockingAdvisoryLockRequest<T0>
16224    where
16225        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16226        ___E: ::fidl_next::Encoder,
16227        T0: ::fidl_next::Encode<crate::wire::AdvisoryLockRequest<'static>, ___E>,
16228    {
16229        #[inline]
16230        fn encode(
16231            self,
16232            encoder_: &mut ___E,
16233            out_: &mut ::core::mem::MaybeUninit<
16234                crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
16235            >,
16236            _: (),
16237        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16238            ::fidl_next::munge! {
16239                let crate::wire::AdvisoryLockingAdvisoryLockRequest {
16240                    request,
16241
16242                } = out_;
16243            }
16244
16245            ::fidl_next::Encode::encode(self.request, encoder_, request, ())?;
16246
16247            Ok(())
16248        }
16249    }
16250
16251    /// The generic type corresponding to [`AdvisoryLockingAdvisoryLockResponse`].
16252    pub type AdvisoryLockingAdvisoryLockResponse = ();
16253
16254    /// The generic type corresponding to [`NodeAttributes`].
16255    pub struct NodeAttributes<T0, T1, T2, T3, T4, T5, T6> {
16256        pub mode: T0,
16257
16258        pub id: T1,
16259
16260        pub content_size: T2,
16261
16262        pub storage_size: T3,
16263
16264        pub link_count: T4,
16265
16266        pub creation_time: T5,
16267
16268        pub modification_time: T6,
16269    }
16270
16271    unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6>
16272        ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>
16273        for NodeAttributes<T0, T1, T2, T3, T4, T5, T6>
16274    where
16275        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16276        T0: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
16277        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16278        T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16279        T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16280        T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16281        T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16282        T6: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16283    {
16284        #[inline]
16285        fn encode(
16286            self,
16287            encoder_: &mut ___E,
16288            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes>,
16289            _: (),
16290        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16291            ::fidl_next::munge! {
16292                let crate::wire::NodeAttributes {
16293                    mode,
16294                    id,
16295                    content_size,
16296                    storage_size,
16297                    link_count,
16298                    creation_time,
16299                    modification_time,
16300
16301                } = out_;
16302            }
16303
16304            ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
16305
16306            ::fidl_next::Encode::encode(self.id, encoder_, id, ())?;
16307
16308            ::fidl_next::Encode::encode(self.content_size, encoder_, content_size, ())?;
16309
16310            ::fidl_next::Encode::encode(self.storage_size, encoder_, storage_size, ())?;
16311
16312            ::fidl_next::Encode::encode(self.link_count, encoder_, link_count, ())?;
16313
16314            ::fidl_next::Encode::encode(self.creation_time, encoder_, creation_time, ())?;
16315
16316            ::fidl_next::Encode::encode(self.modification_time, encoder_, modification_time, ())?;
16317
16318            Ok(())
16319        }
16320    }
16321
16322    /// The generic type corresponding to [`NodeQueryFilesystemResponse`].
16323    pub struct NodeQueryFilesystemResponse<T0, T1> {
16324        pub s: T0,
16325
16326        pub info: T1,
16327    }
16328
16329    unsafe impl<___E, T0, T1>
16330        ::fidl_next::Encode<crate::wire::NodeQueryFilesystemResponse<'static>, ___E>
16331        for NodeQueryFilesystemResponse<T0, T1>
16332    where
16333        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16334        ___E: ::fidl_next::Encoder,
16335        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16336        T1: ::fidl_next::Encode<::fidl_next::wire::Box<'static, crate::wire::FilesystemInfo>, ___E>,
16337    {
16338        #[inline]
16339        fn encode(
16340            self,
16341            encoder_: &mut ___E,
16342            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeQueryFilesystemResponse<'static>>,
16343            _: (),
16344        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16345            ::fidl_next::munge! {
16346                let crate::wire::NodeQueryFilesystemResponse {
16347                    s,
16348                    info,
16349
16350                } = out_;
16351            }
16352
16353            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16354
16355            ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
16356
16357            Ok(())
16358        }
16359    }
16360
16361    /// The generic type corresponding to [`NodeUpdateAttributesResponse`].
16362    pub type NodeUpdateAttributesResponse = ();
16363
16364    /// The generic type corresponding to [`NodeSyncResponse`].
16365    pub type NodeSyncResponse = ();
16366
16367    /// The generic type corresponding to [`DirectoryReadDirentsRequest`].
16368    pub struct DirectoryReadDirentsRequest<T0> {
16369        pub max_bytes: T0,
16370    }
16371
16372    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryReadDirentsRequest, ___E>
16373        for DirectoryReadDirentsRequest<T0>
16374    where
16375        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16376        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
16377    {
16378        #[inline]
16379        fn encode(
16380            self,
16381            encoder_: &mut ___E,
16382            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsRequest>,
16383            _: (),
16384        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16385            ::fidl_next::munge! {
16386                let crate::wire::DirectoryReadDirentsRequest {
16387                    max_bytes,
16388
16389                } = out_;
16390            }
16391
16392            ::fidl_next::Encode::encode(self.max_bytes, encoder_, max_bytes, ())?;
16393
16394            Ok(())
16395        }
16396    }
16397
16398    /// The generic type corresponding to [`DirectoryReadDirentsResponse`].
16399    pub struct DirectoryReadDirentsResponse<T0, T1> {
16400        pub s: T0,
16401
16402        pub dirents: T1,
16403    }
16404
16405    unsafe impl<___E, T0, T1>
16406        ::fidl_next::Encode<crate::wire::DirectoryReadDirentsResponse<'static>, ___E>
16407        for DirectoryReadDirentsResponse<T0, T1>
16408    where
16409        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16410        ___E: ::fidl_next::Encoder,
16411        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16412        T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16413    {
16414        #[inline]
16415        fn encode(
16416            self,
16417            encoder_: &mut ___E,
16418            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryReadDirentsResponse<'static>>,
16419            _: (),
16420        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16421            ::fidl_next::munge! {
16422                let crate::wire::DirectoryReadDirentsResponse {
16423                    s,
16424                    dirents,
16425
16426                } = out_;
16427            }
16428
16429            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16430
16431            ::fidl_next::Encode::encode(self.dirents, encoder_, dirents, (8192, ()))?;
16432
16433            Ok(())
16434        }
16435    }
16436
16437    /// The generic type corresponding to [`DirectoryRewindResponse`].
16438    pub struct DirectoryRewindResponse<T0> {
16439        pub s: T0,
16440    }
16441
16442    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryRewindResponse, ___E>
16443        for DirectoryRewindResponse<T0>
16444    where
16445        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16446        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16447    {
16448        #[inline]
16449        fn encode(
16450            self,
16451            encoder_: &mut ___E,
16452            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRewindResponse>,
16453            _: (),
16454        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16455            ::fidl_next::munge! {
16456                let crate::wire::DirectoryRewindResponse {
16457                    s,
16458
16459                } = out_;
16460            }
16461
16462            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16463
16464            Ok(())
16465        }
16466    }
16467
16468    /// The generic type corresponding to [`DirectoryLinkResponse`].
16469    pub struct DirectoryLinkResponse<T0> {
16470        pub s: T0,
16471    }
16472
16473    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryLinkResponse, ___E>
16474        for DirectoryLinkResponse<T0>
16475    where
16476        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16477        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16478    {
16479        #[inline]
16480        fn encode(
16481            self,
16482            encoder_: &mut ___E,
16483            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkResponse>,
16484            _: (),
16485        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16486            ::fidl_next::munge! {
16487                let crate::wire::DirectoryLinkResponse {
16488                    s,
16489
16490                } = out_;
16491            }
16492
16493            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16494
16495            Ok(())
16496        }
16497    }
16498
16499    /// The generic type corresponding to [`DirectoryUnlinkRequest`].
16500    pub struct DirectoryUnlinkRequest<T0, T1> {
16501        pub name: T0,
16502
16503        pub options: T1,
16504    }
16505
16506    unsafe impl<___E, T0, T1>
16507        ::fidl_next::Encode<crate::wire::DirectoryUnlinkRequest<'static>, ___E>
16508        for DirectoryUnlinkRequest<T0, T1>
16509    where
16510        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16511        ___E: ::fidl_next::Encoder,
16512        T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
16513        T1: ::fidl_next::Encode<crate::wire::UnlinkOptions<'static>, ___E>,
16514    {
16515        #[inline]
16516        fn encode(
16517            self,
16518            encoder_: &mut ___E,
16519            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryUnlinkRequest<'static>>,
16520            _: (),
16521        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16522            ::fidl_next::munge! {
16523                let crate::wire::DirectoryUnlinkRequest {
16524                    name,
16525                    options,
16526
16527                } = out_;
16528            }
16529
16530            ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
16531
16532            ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
16533
16534            Ok(())
16535        }
16536    }
16537
16538    /// The generic type corresponding to [`DirectoryUnlinkResponse`].
16539    pub type DirectoryUnlinkResponse = ();
16540
16541    /// The generic type corresponding to [`DirectoryRenameResponse`].
16542    pub type DirectoryRenameResponse = ();
16543
16544    /// The generic type corresponding to [`DirectoryWatchResponse`].
16545    pub struct DirectoryWatchResponse<T0> {
16546        pub s: T0,
16547    }
16548
16549    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::DirectoryWatchResponse, ___E>
16550        for DirectoryWatchResponse<T0>
16551    where
16552        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16553        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16554    {
16555        #[inline]
16556        fn encode(
16557            self,
16558            encoder_: &mut ___E,
16559            out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchResponse>,
16560            _: (),
16561        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16562            ::fidl_next::munge! {
16563                let crate::wire::DirectoryWatchResponse {
16564                    s,
16565
16566                } = out_;
16567            }
16568
16569            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16570
16571            Ok(())
16572        }
16573    }
16574
16575    /// The generic type corresponding to [`NodeGetExtendedAttributeRequest`].
16576    pub struct NodeGetExtendedAttributeRequest<T0> {
16577        pub name: T0,
16578    }
16579
16580    unsafe impl<___E, T0>
16581        ::fidl_next::Encode<crate::wire::NodeGetExtendedAttributeRequest<'static>, ___E>
16582        for NodeGetExtendedAttributeRequest<T0>
16583    where
16584        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16585        ___E: ::fidl_next::Encoder,
16586        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16587    {
16588        #[inline]
16589        fn encode(
16590            self,
16591            encoder_: &mut ___E,
16592            out_: &mut ::core::mem::MaybeUninit<
16593                crate::wire::NodeGetExtendedAttributeRequest<'static>,
16594            >,
16595            _: (),
16596        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16597            ::fidl_next::munge! {
16598                let crate::wire::NodeGetExtendedAttributeRequest {
16599                    name,
16600
16601                } = out_;
16602            }
16603
16604            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
16605
16606            Ok(())
16607        }
16608    }
16609
16610    /// The generic type corresponding to [`NodeSetExtendedAttributeResponse`].
16611    pub type NodeSetExtendedAttributeResponse = ();
16612
16613    /// The generic type corresponding to [`NodeRemoveExtendedAttributeRequest`].
16614    pub struct NodeRemoveExtendedAttributeRequest<T0> {
16615        pub name: T0,
16616    }
16617
16618    unsafe impl<___E, T0>
16619        ::fidl_next::Encode<crate::wire::NodeRemoveExtendedAttributeRequest<'static>, ___E>
16620        for NodeRemoveExtendedAttributeRequest<T0>
16621    where
16622        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16623        ___E: ::fidl_next::Encoder,
16624        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
16625    {
16626        #[inline]
16627        fn encode(
16628            self,
16629            encoder_: &mut ___E,
16630            out_: &mut ::core::mem::MaybeUninit<
16631                crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
16632            >,
16633            _: (),
16634        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16635            ::fidl_next::munge! {
16636                let crate::wire::NodeRemoveExtendedAttributeRequest {
16637                    name,
16638
16639                } = out_;
16640            }
16641
16642            ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
16643
16644            Ok(())
16645        }
16646    }
16647
16648    /// The generic type corresponding to [`NodeRemoveExtendedAttributeResponse`].
16649    pub type NodeRemoveExtendedAttributeResponse = ();
16650
16651    /// The generic type corresponding to [`DirectoryCreateSymlinkResponse`].
16652    pub type DirectoryCreateSymlinkResponse = ();
16653
16654    /// The generic type corresponding to [`NodeSetFlagsResponse`].
16655    pub type NodeSetFlagsResponse = ();
16656
16657    /// The generic type corresponding to [`NodeDeprecatedGetAttrResponse`].
16658    pub struct NodeDeprecatedGetAttrResponse<T0, T1> {
16659        pub s: T0,
16660
16661        pub attributes: T1,
16662    }
16663
16664    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetAttrResponse, ___E>
16665        for NodeDeprecatedGetAttrResponse<T0, T1>
16666    where
16667        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16668        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16669        T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
16670    {
16671        #[inline]
16672        fn encode(
16673            self,
16674            encoder_: &mut ___E,
16675            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetAttrResponse>,
16676            _: (),
16677        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16678            ::fidl_next::munge! {
16679                let crate::wire::NodeDeprecatedGetAttrResponse {
16680                    s,
16681                    attributes,
16682
16683                } = out_;
16684            }
16685
16686            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16687
16688            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
16689
16690            Ok(())
16691        }
16692    }
16693
16694    /// The generic type corresponding to [`NodeDeprecatedSetAttrRequest`].
16695    pub struct NodeDeprecatedSetAttrRequest<T0, T1> {
16696        pub flags: T0,
16697
16698        pub attributes: T1,
16699    }
16700
16701    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrRequest, ___E>
16702        for NodeDeprecatedSetAttrRequest<T0, T1>
16703    where
16704        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16705        T0: ::fidl_next::Encode<crate::wire::NodeAttributeFlags, ___E>,
16706        T1: ::fidl_next::Encode<crate::wire::NodeAttributes, ___E>,
16707    {
16708        #[inline]
16709        fn encode(
16710            self,
16711            encoder_: &mut ___E,
16712            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrRequest>,
16713            _: (),
16714        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16715            ::fidl_next::munge! {
16716                let crate::wire::NodeDeprecatedSetAttrRequest {
16717                    flags,
16718                    attributes,
16719
16720                } = out_;
16721            }
16722
16723            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16724
16725            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, ())?;
16726
16727            Ok(())
16728        }
16729    }
16730
16731    /// The generic type corresponding to [`NodeDeprecatedSetAttrResponse`].
16732    pub struct NodeDeprecatedSetAttrResponse<T0> {
16733        pub s: T0,
16734    }
16735
16736    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetAttrResponse, ___E>
16737        for NodeDeprecatedSetAttrResponse<T0>
16738    where
16739        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16740        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16741    {
16742        #[inline]
16743        fn encode(
16744            self,
16745            encoder_: &mut ___E,
16746            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetAttrResponse>,
16747            _: (),
16748        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16749            ::fidl_next::munge! {
16750                let crate::wire::NodeDeprecatedSetAttrResponse {
16751                    s,
16752
16753                } = out_;
16754            }
16755
16756            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16757
16758            Ok(())
16759        }
16760    }
16761
16762    /// The generic type corresponding to [`NodeDeprecatedGetFlagsResponse`].
16763    pub struct NodeDeprecatedGetFlagsResponse<T0, T1> {
16764        pub s: T0,
16765
16766        pub flags: T1,
16767    }
16768
16769    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeDeprecatedGetFlagsResponse, ___E>
16770        for NodeDeprecatedGetFlagsResponse<T0, T1>
16771    where
16772        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16773        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16774        T1: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
16775    {
16776        #[inline]
16777        fn encode(
16778            self,
16779            encoder_: &mut ___E,
16780            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedGetFlagsResponse>,
16781            _: (),
16782        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16783            ::fidl_next::munge! {
16784                let crate::wire::NodeDeprecatedGetFlagsResponse {
16785                    s,
16786                    flags,
16787
16788                } = out_;
16789            }
16790
16791            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16792
16793            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16794
16795            Ok(())
16796        }
16797    }
16798
16799    /// The generic type corresponding to [`NodeDeprecatedSetFlagsRequest`].
16800    pub struct NodeDeprecatedSetFlagsRequest<T0> {
16801        pub flags: T0,
16802    }
16803
16804    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsRequest, ___E>
16805        for NodeDeprecatedSetFlagsRequest<T0>
16806    where
16807        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16808        T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
16809    {
16810        #[inline]
16811        fn encode(
16812            self,
16813            encoder_: &mut ___E,
16814            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsRequest>,
16815            _: (),
16816        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16817            ::fidl_next::munge! {
16818                let crate::wire::NodeDeprecatedSetFlagsRequest {
16819                    flags,
16820
16821                } = out_;
16822            }
16823
16824            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16825
16826            Ok(())
16827        }
16828    }
16829
16830    /// The generic type corresponding to [`NodeDeprecatedSetFlagsResponse`].
16831    pub struct NodeDeprecatedSetFlagsResponse<T0> {
16832        pub s: T0,
16833    }
16834
16835    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeDeprecatedSetFlagsResponse, ___E>
16836        for NodeDeprecatedSetFlagsResponse<T0>
16837    where
16838        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16839        T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Status, ___E>,
16840    {
16841        #[inline]
16842        fn encode(
16843            self,
16844            encoder_: &mut ___E,
16845            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeDeprecatedSetFlagsResponse>,
16846            _: (),
16847        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16848            ::fidl_next::munge! {
16849                let crate::wire::NodeDeprecatedSetFlagsResponse {
16850                    s,
16851
16852                } = out_;
16853            }
16854
16855            ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
16856
16857            Ok(())
16858        }
16859    }
16860
16861    /// The generic type corresponding to [`NodeGetFlagsResponse`].
16862    pub struct NodeGetFlagsResponse<T0> {
16863        pub flags: T0,
16864    }
16865
16866    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetFlagsResponse, ___E>
16867        for NodeGetFlagsResponse<T0>
16868    where
16869        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16870        T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
16871    {
16872        #[inline]
16873        fn encode(
16874            self,
16875            encoder_: &mut ___E,
16876            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetFlagsResponse>,
16877            _: (),
16878        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16879            ::fidl_next::munge! {
16880                let crate::wire::NodeGetFlagsResponse {
16881                    flags,
16882
16883                } = out_;
16884            }
16885
16886            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16887
16888            Ok(())
16889        }
16890    }
16891
16892    /// The generic type corresponding to [`NodeSetFlagsRequest`].
16893    pub struct NodeSetFlagsRequest<T0> {
16894        pub flags: T0,
16895    }
16896
16897    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeSetFlagsRequest, ___E>
16898        for NodeSetFlagsRequest<T0>
16899    where
16900        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16901        T0: ::fidl_next::Encode<crate::wire::Flags, ___E>,
16902    {
16903        #[inline]
16904        fn encode(
16905            self,
16906            encoder_: &mut ___E,
16907            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeSetFlagsRequest>,
16908            _: (),
16909        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16910            ::fidl_next::munge! {
16911                let crate::wire::NodeSetFlagsRequest {
16912                    flags,
16913
16914                } = out_;
16915            }
16916
16917            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
16918
16919            Ok(())
16920        }
16921    }
16922
16923    /// The generic type corresponding to [`EmptyStruct`].
16924    pub type EmptyStruct = ();
16925
16926    /// The generic type corresponding to [`NodeAttributes2`].
16927    pub struct NodeAttributes2<T0, T1> {
16928        pub mutable_attributes: T0,
16929
16930        pub immutable_attributes: T1,
16931    }
16932
16933    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeAttributes2<'static>, ___E>
16934        for NodeAttributes2<T0, T1>
16935    where
16936        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16937        ___E: ::fidl_next::Encoder,
16938        T0: ::fidl_next::Encode<crate::wire::MutableNodeAttributes<'static>, ___E>,
16939        T1: ::fidl_next::Encode<crate::wire::ImmutableNodeAttributes<'static>, ___E>,
16940    {
16941        #[inline]
16942        fn encode(
16943            self,
16944            encoder_: &mut ___E,
16945            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeAttributes2<'static>>,
16946            _: (),
16947        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16948            ::fidl_next::munge! {
16949                let crate::wire::NodeAttributes2 {
16950                    mutable_attributes,
16951                    immutable_attributes,
16952
16953                } = out_;
16954            }
16955
16956            ::fidl_next::Encode::encode(self.mutable_attributes, encoder_, mutable_attributes, ())?;
16957
16958            ::fidl_next::Encode::encode(
16959                self.immutable_attributes,
16960                encoder_,
16961                immutable_attributes,
16962                (),
16963            )?;
16964
16965            Ok(())
16966        }
16967    }
16968
16969    /// The generic type corresponding to [`NodeGetAttributesRequest`].
16970    pub struct NodeGetAttributesRequest<T0> {
16971        pub query: T0,
16972    }
16973
16974    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetAttributesRequest, ___E>
16975        for NodeGetAttributesRequest<T0>
16976    where
16977        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
16978        T0: ::fidl_next::Encode<crate::wire::NodeAttributesQuery, ___E>,
16979    {
16980        #[inline]
16981        fn encode(
16982            self,
16983            encoder_: &mut ___E,
16984            out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetAttributesRequest>,
16985            _: (),
16986        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
16987            ::fidl_next::munge! {
16988                let crate::wire::NodeGetAttributesRequest {
16989                    query,
16990
16991                } = out_;
16992            }
16993
16994            ::fidl_next::Encode::encode(self.query, encoder_, query, ())?;
16995
16996            Ok(())
16997        }
16998    }
16999
17000    /// The generic type corresponding to [`DirectoryObject`].
17001    pub type DirectoryObject = ();
17002
17003    /// The generic type corresponding to [`ExtendedAttributeIteratorGetNextResponse`].
17004    pub struct ExtendedAttributeIteratorGetNextResponse<T0, T1> {
17005        pub attributes: T0,
17006
17007        pub last: T1,
17008    }
17009
17010    unsafe impl<___E, T0, T1>
17011        ::fidl_next::Encode<crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>, ___E>
17012        for ExtendedAttributeIteratorGetNextResponse<T0, T1>
17013    where
17014        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17015        ___E: ::fidl_next::Encoder,
17016        T0: ::fidl_next::Encode<
17017                ::fidl_next::wire::Vector<'static, ::fidl_next::wire::Vector<'static, u8>>,
17018                ___E,
17019            >,
17020        T1: ::fidl_next::Encode<bool, ___E>,
17021    {
17022        #[inline]
17023        fn encode(
17024            self,
17025            encoder_: &mut ___E,
17026            out_: &mut ::core::mem::MaybeUninit<
17027                crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
17028            >,
17029            _: (),
17030        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17031            ::fidl_next::munge! {
17032                let crate::wire::ExtendedAttributeIteratorGetNextResponse {
17033                    attributes,
17034                    last,
17035
17036                } = out_;
17037            }
17038
17039            ::fidl_next::Encode::encode(self.attributes, encoder_, attributes, (128, (255, ())))?;
17040
17041            ::fidl_next::Encode::encode(self.last, encoder_, last, ())?;
17042
17043            Ok(())
17044        }
17045    }
17046
17047    /// The generic type corresponding to [`ReadableReadRequest`].
17048    pub struct ReadableReadRequest<T0> {
17049        pub count: T0,
17050    }
17051
17052    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadRequest, ___E>
17053        for ReadableReadRequest<T0>
17054    where
17055        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17056        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17057    {
17058        #[inline]
17059        fn encode(
17060            self,
17061            encoder_: &mut ___E,
17062            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadRequest>,
17063            _: (),
17064        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17065            ::fidl_next::munge! {
17066                let crate::wire::ReadableReadRequest {
17067                    count,
17068
17069                } = out_;
17070            }
17071
17072            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
17073
17074            Ok(())
17075        }
17076    }
17077
17078    /// The generic type corresponding to [`ReadableReadResponse`].
17079    pub struct ReadableReadResponse<T0> {
17080        pub data: T0,
17081    }
17082
17083    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ReadableReadResponse<'static>, ___E>
17084        for ReadableReadResponse<T0>
17085    where
17086        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17087        ___E: ::fidl_next::Encoder,
17088        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17089    {
17090        #[inline]
17091        fn encode(
17092            self,
17093            encoder_: &mut ___E,
17094            out_: &mut ::core::mem::MaybeUninit<crate::wire::ReadableReadResponse<'static>>,
17095            _: (),
17096        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17097            ::fidl_next::munge! {
17098                let crate::wire::ReadableReadResponse {
17099                    data,
17100
17101                } = out_;
17102            }
17103
17104            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17105
17106            Ok(())
17107        }
17108    }
17109
17110    /// The generic type corresponding to [`WritableWriteRequest`].
17111    pub struct WritableWriteRequest<T0> {
17112        pub data: T0,
17113    }
17114
17115    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteRequest<'static>, ___E>
17116        for WritableWriteRequest<T0>
17117    where
17118        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17119        ___E: ::fidl_next::Encoder,
17120        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17121    {
17122        #[inline]
17123        fn encode(
17124            self,
17125            encoder_: &mut ___E,
17126            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteRequest<'static>>,
17127            _: (),
17128        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17129            ::fidl_next::munge! {
17130                let crate::wire::WritableWriteRequest {
17131                    data,
17132
17133                } = out_;
17134            }
17135
17136            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17137
17138            Ok(())
17139        }
17140    }
17141
17142    /// The generic type corresponding to [`WritableWriteResponse`].
17143    pub struct WritableWriteResponse<T0> {
17144        pub actual_count: T0,
17145    }
17146
17147    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::WritableWriteResponse, ___E>
17148        for WritableWriteResponse<T0>
17149    where
17150        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17151        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17152    {
17153        #[inline]
17154        fn encode(
17155            self,
17156            encoder_: &mut ___E,
17157            out_: &mut ::core::mem::MaybeUninit<crate::wire::WritableWriteResponse>,
17158            _: (),
17159        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17160            ::fidl_next::munge! {
17161                let crate::wire::WritableWriteResponse {
17162                    actual_count,
17163
17164                } = out_;
17165            }
17166
17167            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
17168
17169            Ok(())
17170        }
17171    }
17172
17173    /// The generic type corresponding to [`FileSeekRequest`].
17174    pub struct FileSeekRequest<T0, T1> {
17175        pub origin: T0,
17176
17177        pub offset: T1,
17178    }
17179
17180    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileSeekRequest, ___E>
17181        for FileSeekRequest<T0, T1>
17182    where
17183        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17184        T0: ::fidl_next::Encode<crate::wire::SeekOrigin, ___E>,
17185        T1: ::fidl_next::Encode<::fidl_next::wire::Int64, ___E>,
17186    {
17187        #[inline]
17188        fn encode(
17189            self,
17190            encoder_: &mut ___E,
17191            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekRequest>,
17192            _: (),
17193        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17194            ::fidl_next::munge! {
17195                let crate::wire::FileSeekRequest {
17196                    origin,
17197                    offset,
17198
17199                } = out_;
17200            }
17201
17202            ::fidl_next::Encode::encode(self.origin, encoder_, origin, ())?;
17203
17204            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17205
17206            Ok(())
17207        }
17208    }
17209
17210    /// The generic type corresponding to [`FileSeekResponse`].
17211    pub struct FileSeekResponse<T0> {
17212        pub offset_from_start: T0,
17213    }
17214
17215    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileSeekResponse, ___E>
17216        for FileSeekResponse<T0>
17217    where
17218        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17219        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17220    {
17221        #[inline]
17222        fn encode(
17223            self,
17224            encoder_: &mut ___E,
17225            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileSeekResponse>,
17226            _: (),
17227        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17228            ::fidl_next::munge! {
17229                let crate::wire::FileSeekResponse {
17230                    offset_from_start,
17231
17232                } = out_;
17233            }
17234
17235            ::fidl_next::Encode::encode(self.offset_from_start, encoder_, offset_from_start, ())?;
17236
17237            Ok(())
17238        }
17239    }
17240
17241    /// The generic type corresponding to [`FileReadAtRequest`].
17242    pub struct FileReadAtRequest<T0, T1> {
17243        pub count: T0,
17244
17245        pub offset: T1,
17246    }
17247
17248    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileReadAtRequest, ___E>
17249        for FileReadAtRequest<T0, T1>
17250    where
17251        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17252        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17253        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17254    {
17255        #[inline]
17256        fn encode(
17257            self,
17258            encoder_: &mut ___E,
17259            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtRequest>,
17260            _: (),
17261        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17262            ::fidl_next::munge! {
17263                let crate::wire::FileReadAtRequest {
17264                    count,
17265                    offset,
17266
17267                } = out_;
17268            }
17269
17270            ::fidl_next::Encode::encode(self.count, encoder_, count, ())?;
17271
17272            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17273
17274            Ok(())
17275        }
17276    }
17277
17278    /// The generic type corresponding to [`FileReadAtResponse`].
17279    pub struct FileReadAtResponse<T0> {
17280        pub data: T0,
17281    }
17282
17283    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileReadAtResponse<'static>, ___E>
17284        for FileReadAtResponse<T0>
17285    where
17286        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17287        ___E: ::fidl_next::Encoder,
17288        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17289    {
17290        #[inline]
17291        fn encode(
17292            self,
17293            encoder_: &mut ___E,
17294            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileReadAtResponse<'static>>,
17295            _: (),
17296        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17297            ::fidl_next::munge! {
17298                let crate::wire::FileReadAtResponse {
17299                    data,
17300
17301                } = out_;
17302            }
17303
17304            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17305
17306            Ok(())
17307        }
17308    }
17309
17310    /// The generic type corresponding to [`FileWriteAtRequest`].
17311    pub struct FileWriteAtRequest<T0, T1> {
17312        pub data: T0,
17313
17314        pub offset: T1,
17315    }
17316
17317    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileWriteAtRequest<'static>, ___E>
17318        for FileWriteAtRequest<T0, T1>
17319    where
17320        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17321        ___E: ::fidl_next::Encoder,
17322        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17323        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17324    {
17325        #[inline]
17326        fn encode(
17327            self,
17328            encoder_: &mut ___E,
17329            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtRequest<'static>>,
17330            _: (),
17331        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17332            ::fidl_next::munge! {
17333                let crate::wire::FileWriteAtRequest {
17334                    data,
17335                    offset,
17336
17337                } = out_;
17338            }
17339
17340            ::fidl_next::Encode::encode(self.data, encoder_, data, (8192, ()))?;
17341
17342            ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
17343
17344            Ok(())
17345        }
17346    }
17347
17348    /// The generic type corresponding to [`FileWriteAtResponse`].
17349    pub struct FileWriteAtResponse<T0> {
17350        pub actual_count: T0,
17351    }
17352
17353    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileWriteAtResponse, ___E>
17354        for FileWriteAtResponse<T0>
17355    where
17356        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17357        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17358    {
17359        #[inline]
17360        fn encode(
17361            self,
17362            encoder_: &mut ___E,
17363            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileWriteAtResponse>,
17364            _: (),
17365        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17366            ::fidl_next::munge! {
17367                let crate::wire::FileWriteAtResponse {
17368                    actual_count,
17369
17370                } = out_;
17371            }
17372
17373            ::fidl_next::Encode::encode(self.actual_count, encoder_, actual_count, ())?;
17374
17375            Ok(())
17376        }
17377    }
17378
17379    /// The generic type corresponding to [`FileResizeRequest`].
17380    pub struct FileResizeRequest<T0> {
17381        pub length: T0,
17382    }
17383
17384    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileResizeRequest, ___E>
17385        for FileResizeRequest<T0>
17386    where
17387        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17388        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17389    {
17390        #[inline]
17391        fn encode(
17392            self,
17393            encoder_: &mut ___E,
17394            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileResizeRequest>,
17395            _: (),
17396        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17397            ::fidl_next::munge! {
17398                let crate::wire::FileResizeRequest {
17399                    length,
17400
17401                } = out_;
17402            }
17403
17404            ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
17405
17406            Ok(())
17407        }
17408    }
17409
17410    /// The generic type corresponding to [`FileResizeResponse`].
17411    pub type FileResizeResponse = ();
17412
17413    /// The generic type corresponding to [`FileGetBackingMemoryRequest`].
17414    pub struct FileGetBackingMemoryRequest<T0> {
17415        pub flags: T0,
17416    }
17417
17418    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryRequest, ___E>
17419        for FileGetBackingMemoryRequest<T0>
17420    where
17421        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17422        T0: ::fidl_next::Encode<crate::wire::VmoFlags, ___E>,
17423    {
17424        #[inline]
17425        fn encode(
17426            self,
17427            encoder_: &mut ___E,
17428            out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryRequest>,
17429            _: (),
17430        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17431            ::fidl_next::munge! {
17432                let crate::wire::FileGetBackingMemoryRequest {
17433                    flags,
17434
17435                } = out_;
17436            }
17437
17438            ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
17439
17440            Ok(())
17441        }
17442    }
17443
17444    /// The generic type corresponding to [`LinkableLinkIntoResponse`].
17445    pub type LinkableLinkIntoResponse = ();
17446
17447    /// The generic type corresponding to [`FileAllocateResponse`].
17448    pub type FileAllocateResponse = ();
17449
17450    /// The generic type corresponding to [`FileEnableVerityResponse`].
17451    pub type FileEnableVerityResponse = ();
17452
17453    /// The generic type corresponding to [`FilesystemInfo`].
17454    pub struct FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
17455        pub total_bytes: T0,
17456
17457        pub used_bytes: T1,
17458
17459        pub total_nodes: T2,
17460
17461        pub used_nodes: T3,
17462
17463        pub free_shared_pool_bytes: T4,
17464
17465        pub fs_id: T5,
17466
17467        pub block_size: T6,
17468
17469        pub max_filename_size: T7,
17470
17471        pub fs_type: T8,
17472
17473        pub padding: T9,
17474
17475        pub name: T10,
17476    }
17477
17478    unsafe impl<___E, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
17479        ::fidl_next::Encode<crate::wire::FilesystemInfo, ___E>
17480        for FilesystemInfo<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
17481    where
17482        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17483        T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17484        T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17485        T2: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17486        T3: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17487        T4: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17488        T5: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
17489        T6: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17490        T7: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17491        T8: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17492        T9: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
17493        T10: ::fidl_next::Encode<[i8; 32], ___E>,
17494    {
17495        #[inline]
17496        fn encode(
17497            self,
17498            encoder_: &mut ___E,
17499            out_: &mut ::core::mem::MaybeUninit<crate::wire::FilesystemInfo>,
17500            _: (),
17501        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17502            ::fidl_next::munge! {
17503                let crate::wire::FilesystemInfo {
17504                    total_bytes,
17505                    used_bytes,
17506                    total_nodes,
17507                    used_nodes,
17508                    free_shared_pool_bytes,
17509                    fs_id,
17510                    block_size,
17511                    max_filename_size,
17512                    fs_type,
17513                    padding,
17514                    name,
17515
17516                } = out_;
17517            }
17518
17519            ::fidl_next::Encode::encode(self.total_bytes, encoder_, total_bytes, ())?;
17520
17521            ::fidl_next::Encode::encode(self.used_bytes, encoder_, used_bytes, ())?;
17522
17523            ::fidl_next::Encode::encode(self.total_nodes, encoder_, total_nodes, ())?;
17524
17525            ::fidl_next::Encode::encode(self.used_nodes, encoder_, used_nodes, ())?;
17526
17527            ::fidl_next::Encode::encode(
17528                self.free_shared_pool_bytes,
17529                encoder_,
17530                free_shared_pool_bytes,
17531                (),
17532            )?;
17533
17534            ::fidl_next::Encode::encode(self.fs_id, encoder_, fs_id, ())?;
17535
17536            ::fidl_next::Encode::encode(self.block_size, encoder_, block_size, ())?;
17537
17538            ::fidl_next::Encode::encode(self.max_filename_size, encoder_, max_filename_size, ())?;
17539
17540            ::fidl_next::Encode::encode(self.fs_type, encoder_, fs_type, ())?;
17541
17542            ::fidl_next::Encode::encode(self.padding, encoder_, padding, ())?;
17543
17544            ::fidl_next::Encode::encode(self.name, encoder_, name, ())?;
17545
17546            Ok(())
17547        }
17548    }
17549
17550    /// The generic type corresponding to [`Service`].
17551    pub type Service = ();
17552
17553    /// The generic type corresponding to [`SymlinkObject`].
17554    pub struct SymlinkObject<T0> {
17555        pub target: T0,
17556    }
17557
17558    unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::SymlinkObject<'static>, ___E>
17559        for SymlinkObject<T0>
17560    where
17561        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
17562        ___E: ::fidl_next::Encoder,
17563        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
17564    {
17565        #[inline]
17566        fn encode(
17567            self,
17568            encoder_: &mut ___E,
17569            out_: &mut ::core::mem::MaybeUninit<crate::wire::SymlinkObject<'static>>,
17570            _: (),
17571        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
17572            ::fidl_next::munge! {
17573                let crate::wire::SymlinkObject {
17574                    target,
17575
17576                } = out_;
17577            }
17578
17579            ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
17580
17581            Ok(())
17582        }
17583    }
17584}
17585
17586pub use self::natural::*;
17587
17588/// The type corresponding to the AdvisoryLocking protocol.
17589#[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"]
17590#[derive(PartialEq, Debug)]
17591pub struct AdvisoryLocking;
17592
17593#[cfg(target_os = "fuchsia")]
17594impl ::fidl_next::HasTransport for AdvisoryLocking {
17595    type Transport = ::fidl_next::fuchsia::zx::Channel;
17596}
17597
17598pub mod advisory_locking {
17599    pub mod prelude {
17600        pub use crate::{
17601            AdvisoryLocking, AdvisoryLockingClientHandler, AdvisoryLockingLocalClientHandler,
17602            AdvisoryLockingLocalServerHandler, AdvisoryLockingServerHandler, advisory_locking,
17603        };
17604
17605        pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
17606
17607        pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
17608    }
17609
17610    pub struct AdvisoryLock;
17611
17612    impl ::fidl_next::Method for AdvisoryLock {
17613        const ORDINAL: u64 = 7992130864415541162;
17614        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17615            ::fidl_next::protocol::Flexibility::Strict;
17616
17617        type Protocol = crate::AdvisoryLocking;
17618
17619        type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
17620    }
17621
17622    impl ::fidl_next::TwoWayMethod for AdvisoryLock {
17623        type Response = ::fidl_next::wire::Result<
17624            'static,
17625            crate::wire::AdvisoryLockingAdvisoryLockResponse,
17626            ::fidl_next::wire::fuchsia::Status,
17627        >;
17628    }
17629
17630    impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
17631        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17632
17633        fn respond(response: ___R) -> Self::Output {
17634            ::core::result::Result::Ok(response)
17635        }
17636    }
17637
17638    impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
17639        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17640
17641        fn respond_err(response: ___R) -> Self::Output {
17642            ::core::result::Result::Err(response)
17643        }
17644    }
17645
17646    mod ___detail {
17647        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::AdvisoryLocking
17648        where
17649            ___T: ::fidl_next::Transport,
17650        {
17651            type Client = AdvisoryLockingClient<___T>;
17652            type Server = AdvisoryLockingServer<___T>;
17653        }
17654
17655        /// The client for the `AdvisoryLocking` protocol.
17656        #[repr(transparent)]
17657        pub struct AdvisoryLockingClient<___T: ::fidl_next::Transport> {
17658            #[allow(dead_code)]
17659            client: ::fidl_next::protocol::Client<___T>,
17660        }
17661
17662        impl<___T> AdvisoryLockingClient<___T>
17663        where
17664            ___T: ::fidl_next::Transport,
17665        {
17666            #[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"]
17667            pub fn advisory_lock(
17668                &self,
17669
17670                request: impl ::fidl_next::Encode<
17671                    crate::wire::AdvisoryLockRequest<'static>,
17672                    <___T as ::fidl_next::Transport>::SendBuffer,
17673                >,
17674            ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
17675            where
17676                <___T as ::fidl_next::Transport>::SendBuffer:
17677                    ::fidl_next::encoder::InternalHandleEncoder,
17678                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
17679            {
17680                self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
17681                    request,
17682                })
17683            }
17684
17685            #[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"]
17686            pub fn advisory_lock_with<___R>(
17687                &self,
17688                request: ___R,
17689            ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
17690            where
17691                ___R: ::fidl_next::Encode<
17692                        crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
17693                        <___T as ::fidl_next::Transport>::SendBuffer,
17694                    >,
17695            {
17696                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
17697                    7992130864415541162,
17698                    <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
17699                    request,
17700                ))
17701            }
17702        }
17703
17704        /// The server for the `AdvisoryLocking` protocol.
17705        #[repr(transparent)]
17706        pub struct AdvisoryLockingServer<___T: ::fidl_next::Transport> {
17707            server: ::fidl_next::protocol::Server<___T>,
17708        }
17709
17710        impl<___T> AdvisoryLockingServer<___T> where ___T: ::fidl_next::Transport {}
17711    }
17712}
17713
17714#[diagnostic::on_unimplemented(
17715    note = "If {Self} implements the non-local AdvisoryLockingClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
17716)]
17717
17718/// A client handler for the AdvisoryLocking protocol.
17719///
17720/// See [`AdvisoryLocking`] for more details.
17721pub trait AdvisoryLockingLocalClientHandler<
17722    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17723    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17724>
17725{
17726}
17727
17728impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for AdvisoryLocking
17729where
17730    ___H: AdvisoryLockingLocalClientHandler<___T>,
17731    ___T: ::fidl_next::Transport,
17732{
17733    async fn on_event(
17734        handler: &mut ___H,
17735        mut message: ::fidl_next::Message<___T>,
17736    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17737        match *message.header().ordinal {
17738            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17739        }
17740    }
17741}
17742
17743#[diagnostic::on_unimplemented(
17744    note = "If {Self} implements the non-local AdvisoryLockingServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
17745)]
17746
17747/// A server handler for the AdvisoryLocking protocol.
17748///
17749/// See [`AdvisoryLocking`] for more details.
17750pub trait AdvisoryLockingLocalServerHandler<
17751    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17752    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17753>
17754{
17755    #[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"]
17756    fn advisory_lock(
17757        &mut self,
17758
17759        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17760
17761        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17762    ) -> impl ::core::future::Future<Output = ()>;
17763}
17764
17765impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for AdvisoryLocking
17766where
17767    ___H: AdvisoryLockingLocalServerHandler<___T>,
17768    ___T: ::fidl_next::Transport,
17769    for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
17770            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17771            Constraint = (),
17772        >,
17773{
17774    async fn on_one_way(
17775        handler: &mut ___H,
17776        mut message: ::fidl_next::Message<___T>,
17777    ) -> ::core::result::Result<
17778        (),
17779        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17780    > {
17781        match *message.header().ordinal {
17782            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17783        }
17784    }
17785
17786    async fn on_two_way(
17787        handler: &mut ___H,
17788        mut message: ::fidl_next::Message<___T>,
17789        responder: ::fidl_next::protocol::Responder<___T>,
17790    ) -> ::core::result::Result<
17791        (),
17792        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17793    > {
17794        match *message.header().ordinal {
17795            7992130864415541162 => {
17796                let responder = ::fidl_next::Responder::from_untyped(responder);
17797
17798                match ::fidl_next::AsDecoderExt::into_decoded(message) {
17799                    Ok(decoded) => {
17800                        handler
17801                            .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17802                            .await;
17803                        Ok(())
17804                    }
17805                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17806                        ordinal: 7992130864415541162,
17807                        error,
17808                    }),
17809                }
17810            }
17811
17812            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17813        }
17814    }
17815}
17816
17817/// A client handler for the AdvisoryLocking protocol.
17818///
17819/// See [`AdvisoryLocking`] for more details.
17820pub trait AdvisoryLockingClientHandler<
17821    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17822    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17823>
17824{
17825}
17826
17827impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for AdvisoryLocking
17828where
17829    ___H: AdvisoryLockingClientHandler<___T> + ::core::marker::Send,
17830    ___T: ::fidl_next::Transport,
17831{
17832    async fn on_event(
17833        handler: &mut ___H,
17834        mut message: ::fidl_next::Message<___T>,
17835    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
17836        match *message.header().ordinal {
17837            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17838        }
17839    }
17840}
17841
17842/// A server handler for the AdvisoryLocking protocol.
17843///
17844/// See [`AdvisoryLocking`] for more details.
17845pub trait AdvisoryLockingServerHandler<
17846    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
17847    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
17848>
17849{
17850    #[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"]
17851    fn advisory_lock(
17852        &mut self,
17853
17854        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17855
17856        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17857    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
17858}
17859
17860impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for AdvisoryLocking
17861where
17862    ___H: AdvisoryLockingServerHandler<___T> + ::core::marker::Send,
17863    ___T: ::fidl_next::Transport,
17864    for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
17865            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
17866            Constraint = (),
17867        >,
17868{
17869    async fn on_one_way(
17870        handler: &mut ___H,
17871        mut message: ::fidl_next::Message<___T>,
17872    ) -> ::core::result::Result<
17873        (),
17874        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17875    > {
17876        match *message.header().ordinal {
17877            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17878        }
17879    }
17880
17881    async fn on_two_way(
17882        handler: &mut ___H,
17883        mut message: ::fidl_next::Message<___T>,
17884        responder: ::fidl_next::protocol::Responder<___T>,
17885    ) -> ::core::result::Result<
17886        (),
17887        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17888    > {
17889        match *message.header().ordinal {
17890            7992130864415541162 => {
17891                let responder = ::fidl_next::Responder::from_untyped(responder);
17892
17893                match ::fidl_next::AsDecoderExt::into_decoded(message) {
17894                    Ok(decoded) => {
17895                        handler
17896                            .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17897                            .await;
17898                        Ok(())
17899                    }
17900                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17901                        ordinal: 7992130864415541162,
17902                        error,
17903                    }),
17904                }
17905            }
17906
17907            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
17908        }
17909    }
17910}
17911
17912impl<___T> AdvisoryLockingClientHandler<___T> for ::fidl_next::IgnoreEvents where
17913    ___T: ::fidl_next::Transport
17914{
17915}
17916
17917impl<___H, ___T> AdvisoryLockingLocalClientHandler<___T> for ::fidl_next::Local<___H>
17918where
17919    ___H: AdvisoryLockingClientHandler<___T>,
17920    ___T: ::fidl_next::Transport,
17921{
17922}
17923
17924impl<___H, ___T> AdvisoryLockingLocalServerHandler<___T> for ::fidl_next::Local<___H>
17925where
17926    ___H: AdvisoryLockingServerHandler<___T>,
17927    ___T: ::fidl_next::Transport,
17928{
17929    async fn advisory_lock(
17930        &mut self,
17931
17932        request: ::fidl_next::Request<advisory_locking::AdvisoryLock, ___T>,
17933
17934        responder: ::fidl_next::Responder<advisory_locking::AdvisoryLock, ___T>,
17935    ) {
17936        ___H::advisory_lock(&mut self.0, request, responder).await
17937    }
17938}
17939
17940pub const DIRECTORY_PROTOCOL_NAME: &str = "fuchsia.io/Directory";
17941
17942#[doc = " The maximum length, in bytes, of a filesystem path.\n"]
17943pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
17944
17945#[doc = " The maximal buffer size which can be transmitted for buffered operations.\n This capacity is currently set somewhat arbitrarily.\n"]
17946pub const MAX_BUF: u64 = 8192 as u64;
17947
17948#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
17949pub const MAX_NAME_LENGTH: u64 = 255 as u64;
17950
17951#[doc = " The maximum size for an extended attribute name.\n"]
17952pub const MAX_ATTRIBUTE_NAME: u64 = 255 as u64;
17953
17954#[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"]
17955pub const MAX_INLINE_ATTRIBUTE_VALUE: u64 = 32768 as u64;
17956
17957#[doc = " The maximum size for passing the SELinux context as an attribute.\n"]
17958pub const MAX_SELINUX_CONTEXT_ATTRIBUTE_LEN: u64 = 256 as u64;
17959
17960/// The type corresponding to the DirectoryWatcher protocol.
17961#[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"]
17962#[derive(PartialEq, Debug)]
17963pub struct DirectoryWatcher;
17964
17965#[cfg(target_os = "fuchsia")]
17966impl ::fidl_next::HasTransport for DirectoryWatcher {
17967    type Transport = ::fidl_next::fuchsia::zx::Channel;
17968}
17969
17970pub mod directory_watcher {
17971    pub mod prelude {
17972        pub use crate::{
17973            DirectoryWatcher, DirectoryWatcherClientHandler, DirectoryWatcherLocalClientHandler,
17974            DirectoryWatcherLocalServerHandler, DirectoryWatcherServerHandler, directory_watcher,
17975        };
17976    }
17977
17978    mod ___detail {
17979        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::DirectoryWatcher
17980        where
17981            ___T: ::fidl_next::Transport,
17982        {
17983            type Client = DirectoryWatcherClient<___T>;
17984            type Server = DirectoryWatcherServer<___T>;
17985        }
17986
17987        /// The client for the `DirectoryWatcher` protocol.
17988        #[repr(transparent)]
17989        pub struct DirectoryWatcherClient<___T: ::fidl_next::Transport> {
17990            #[allow(dead_code)]
17991            client: ::fidl_next::protocol::Client<___T>,
17992        }
17993
17994        impl<___T> DirectoryWatcherClient<___T> where ___T: ::fidl_next::Transport {}
17995
17996        /// The server for the `DirectoryWatcher` protocol.
17997        #[repr(transparent)]
17998        pub struct DirectoryWatcherServer<___T: ::fidl_next::Transport> {
17999            server: ::fidl_next::protocol::Server<___T>,
18000        }
18001
18002        impl<___T> DirectoryWatcherServer<___T> where ___T: ::fidl_next::Transport {}
18003    }
18004}
18005
18006#[diagnostic::on_unimplemented(
18007    note = "If {Self} implements the non-local DirectoryWatcherClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18008)]
18009
18010/// A client handler for the DirectoryWatcher protocol.
18011///
18012/// See [`DirectoryWatcher`] for more details.
18013pub trait DirectoryWatcherLocalClientHandler<
18014    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18015    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18016>
18017{
18018}
18019
18020impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for DirectoryWatcher
18021where
18022    ___H: DirectoryWatcherLocalClientHandler<___T>,
18023    ___T: ::fidl_next::Transport,
18024{
18025    async fn on_event(
18026        handler: &mut ___H,
18027        mut message: ::fidl_next::Message<___T>,
18028    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18029        match *message.header().ordinal {
18030            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18031        }
18032    }
18033}
18034
18035#[diagnostic::on_unimplemented(
18036    note = "If {Self} implements the non-local DirectoryWatcherServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18037)]
18038
18039/// A server handler for the DirectoryWatcher protocol.
18040///
18041/// See [`DirectoryWatcher`] for more details.
18042pub trait DirectoryWatcherLocalServerHandler<
18043    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18044    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18045>
18046{
18047}
18048
18049impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for DirectoryWatcher
18050where
18051    ___H: DirectoryWatcherLocalServerHandler<___T>,
18052    ___T: ::fidl_next::Transport,
18053{
18054    async fn on_one_way(
18055        handler: &mut ___H,
18056        mut message: ::fidl_next::Message<___T>,
18057    ) -> ::core::result::Result<
18058        (),
18059        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18060    > {
18061        match *message.header().ordinal {
18062            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18063        }
18064    }
18065
18066    async fn on_two_way(
18067        handler: &mut ___H,
18068        mut message: ::fidl_next::Message<___T>,
18069        responder: ::fidl_next::protocol::Responder<___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
18080/// A client handler for the DirectoryWatcher protocol.
18081///
18082/// See [`DirectoryWatcher`] for more details.
18083pub trait DirectoryWatcherClientHandler<
18084    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18085    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18086>
18087{
18088}
18089
18090impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for DirectoryWatcher
18091where
18092    ___H: DirectoryWatcherClientHandler<___T> + ::core::marker::Send,
18093    ___T: ::fidl_next::Transport,
18094{
18095    async fn on_event(
18096        handler: &mut ___H,
18097        mut message: ::fidl_next::Message<___T>,
18098    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18099        match *message.header().ordinal {
18100            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18101        }
18102    }
18103}
18104
18105/// A server handler for the DirectoryWatcher protocol.
18106///
18107/// See [`DirectoryWatcher`] for more details.
18108pub trait DirectoryWatcherServerHandler<
18109    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18110    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18111>
18112{
18113}
18114
18115impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for DirectoryWatcher
18116where
18117    ___H: DirectoryWatcherServerHandler<___T> + ::core::marker::Send,
18118    ___T: ::fidl_next::Transport,
18119{
18120    async fn on_one_way(
18121        handler: &mut ___H,
18122        mut message: ::fidl_next::Message<___T>,
18123    ) -> ::core::result::Result<
18124        (),
18125        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18126    > {
18127        match *message.header().ordinal {
18128            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18129        }
18130    }
18131
18132    async fn on_two_way(
18133        handler: &mut ___H,
18134        mut message: ::fidl_next::Message<___T>,
18135        responder: ::fidl_next::protocol::Responder<___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
18146impl<___T> DirectoryWatcherClientHandler<___T> for ::fidl_next::IgnoreEvents where
18147    ___T: ::fidl_next::Transport
18148{
18149}
18150
18151impl<___H, ___T> DirectoryWatcherLocalClientHandler<___T> for ::fidl_next::Local<___H>
18152where
18153    ___H: DirectoryWatcherClientHandler<___T>,
18154    ___T: ::fidl_next::Transport,
18155{
18156}
18157
18158impl<___H, ___T> DirectoryWatcherLocalServerHandler<___T> for ::fidl_next::Local<___H>
18159where
18160    ___H: DirectoryWatcherServerHandler<___T>,
18161    ___T: ::fidl_next::Transport,
18162{
18163}
18164
18165#[doc = " The maximum size of a chunk in the ListExtendedAttributes iterator.\n"]
18166pub const MAX_LIST_ATTRIBUTES_CHUNK: u64 = 128 as u64;
18167
18168/// The type corresponding to the ExtendedAttributeIterator protocol.
18169#[derive(PartialEq, Debug)]
18170pub struct ExtendedAttributeIterator;
18171
18172#[cfg(target_os = "fuchsia")]
18173impl ::fidl_next::HasTransport for ExtendedAttributeIterator {
18174    type Transport = ::fidl_next::fuchsia::zx::Channel;
18175}
18176
18177pub mod extended_attribute_iterator {
18178    pub mod prelude {
18179        pub use crate::{
18180            ExtendedAttributeIterator, ExtendedAttributeIteratorClientHandler,
18181            ExtendedAttributeIteratorLocalClientHandler,
18182            ExtendedAttributeIteratorLocalServerHandler, ExtendedAttributeIteratorServerHandler,
18183            extended_attribute_iterator,
18184        };
18185
18186        pub use crate::natural::ExtendedAttributeIteratorGetNextResponse;
18187    }
18188
18189    pub struct GetNext;
18190
18191    impl ::fidl_next::Method for GetNext {
18192        const ORDINAL: u64 = 268639596268373415;
18193        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18194            ::fidl_next::protocol::Flexibility::Strict;
18195
18196        type Protocol = crate::ExtendedAttributeIterator;
18197
18198        type Request = ::fidl_next::wire::EmptyMessageBody;
18199    }
18200
18201    impl ::fidl_next::TwoWayMethod for GetNext {
18202        type Response = ::fidl_next::wire::Result<
18203            'static,
18204            crate::wire::ExtendedAttributeIteratorGetNextResponse<'static>,
18205            ::fidl_next::wire::fuchsia::Status,
18206        >;
18207    }
18208
18209    impl<___R> ::fidl_next::Respond<___R> for GetNext {
18210        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18211
18212        fn respond(response: ___R) -> Self::Output {
18213            ::core::result::Result::Ok(response)
18214        }
18215    }
18216
18217    impl<___R> ::fidl_next::RespondErr<___R> for GetNext {
18218        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18219
18220        fn respond_err(response: ___R) -> Self::Output {
18221            ::core::result::Result::Err(response)
18222        }
18223    }
18224
18225    mod ___detail {
18226        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExtendedAttributeIterator
18227        where
18228            ___T: ::fidl_next::Transport,
18229        {
18230            type Client = ExtendedAttributeIteratorClient<___T>;
18231            type Server = ExtendedAttributeIteratorServer<___T>;
18232        }
18233
18234        /// The client for the `ExtendedAttributeIterator` protocol.
18235        #[repr(transparent)]
18236        pub struct ExtendedAttributeIteratorClient<___T: ::fidl_next::Transport> {
18237            #[allow(dead_code)]
18238            client: ::fidl_next::protocol::Client<___T>,
18239        }
18240
18241        impl<___T> ExtendedAttributeIteratorClient<___T>
18242        where
18243            ___T: ::fidl_next::Transport,
18244        {
18245            #[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"]
18246            pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
18247                ::fidl_next::TwoWayFuture::from_untyped(
18248                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18249                        268639596268373415,
18250                        <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
18251                        (),
18252                    ),
18253                )
18254            }
18255        }
18256
18257        /// The server for the `ExtendedAttributeIterator` protocol.
18258        #[repr(transparent)]
18259        pub struct ExtendedAttributeIteratorServer<___T: ::fidl_next::Transport> {
18260            server: ::fidl_next::protocol::Server<___T>,
18261        }
18262
18263        impl<___T> ExtendedAttributeIteratorServer<___T> where ___T: ::fidl_next::Transport {}
18264    }
18265}
18266
18267#[diagnostic::on_unimplemented(
18268    note = "If {Self} implements the non-local ExtendedAttributeIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18269)]
18270
18271/// A client handler for the ExtendedAttributeIterator protocol.
18272///
18273/// See [`ExtendedAttributeIterator`] for more details.
18274pub trait ExtendedAttributeIteratorLocalClientHandler<
18275    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18276    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18277>
18278{
18279}
18280
18281impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExtendedAttributeIterator
18282where
18283    ___H: ExtendedAttributeIteratorLocalClientHandler<___T>,
18284    ___T: ::fidl_next::Transport,
18285{
18286    async fn on_event(
18287        handler: &mut ___H,
18288        mut message: ::fidl_next::Message<___T>,
18289    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18290        match *message.header().ordinal {
18291            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18292        }
18293    }
18294}
18295
18296#[diagnostic::on_unimplemented(
18297    note = "If {Self} implements the non-local ExtendedAttributeIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18298)]
18299
18300/// A server handler for the ExtendedAttributeIterator protocol.
18301///
18302/// See [`ExtendedAttributeIterator`] for more details.
18303pub trait ExtendedAttributeIteratorLocalServerHandler<
18304    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18305    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18306>
18307{
18308    #[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"]
18309    fn get_next(
18310        &mut self,
18311
18312        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18313    ) -> impl ::core::future::Future<Output = ()>;
18314}
18315
18316impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExtendedAttributeIterator
18317where
18318    ___H: ExtendedAttributeIteratorLocalServerHandler<___T>,
18319    ___T: ::fidl_next::Transport,
18320{
18321    async fn on_one_way(
18322        handler: &mut ___H,
18323        mut message: ::fidl_next::Message<___T>,
18324    ) -> ::core::result::Result<
18325        (),
18326        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18327    > {
18328        match *message.header().ordinal {
18329            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18330        }
18331    }
18332
18333    async fn on_two_way(
18334        handler: &mut ___H,
18335        mut message: ::fidl_next::Message<___T>,
18336        responder: ::fidl_next::protocol::Responder<___T>,
18337    ) -> ::core::result::Result<
18338        (),
18339        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18340    > {
18341        match *message.header().ordinal {
18342            268639596268373415 => {
18343                let responder = ::fidl_next::Responder::from_untyped(responder);
18344
18345                handler.get_next(responder).await;
18346                Ok(())
18347            }
18348
18349            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18350        }
18351    }
18352}
18353
18354/// A client handler for the ExtendedAttributeIterator protocol.
18355///
18356/// See [`ExtendedAttributeIterator`] for more details.
18357pub trait ExtendedAttributeIteratorClientHandler<
18358    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18359    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18360>
18361{
18362}
18363
18364impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExtendedAttributeIterator
18365where
18366    ___H: ExtendedAttributeIteratorClientHandler<___T> + ::core::marker::Send,
18367    ___T: ::fidl_next::Transport,
18368{
18369    async fn on_event(
18370        handler: &mut ___H,
18371        mut message: ::fidl_next::Message<___T>,
18372    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18373        match *message.header().ordinal {
18374            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18375        }
18376    }
18377}
18378
18379/// A server handler for the ExtendedAttributeIterator protocol.
18380///
18381/// See [`ExtendedAttributeIterator`] for more details.
18382pub trait ExtendedAttributeIteratorServerHandler<
18383    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18384    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18385>
18386{
18387    #[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"]
18388    fn get_next(
18389        &mut self,
18390
18391        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18392    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18393}
18394
18395impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExtendedAttributeIterator
18396where
18397    ___H: ExtendedAttributeIteratorServerHandler<___T> + ::core::marker::Send,
18398    ___T: ::fidl_next::Transport,
18399{
18400    async fn on_one_way(
18401        handler: &mut ___H,
18402        mut message: ::fidl_next::Message<___T>,
18403    ) -> ::core::result::Result<
18404        (),
18405        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18406    > {
18407        match *message.header().ordinal {
18408            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18409        }
18410    }
18411
18412    async fn on_two_way(
18413        handler: &mut ___H,
18414        mut message: ::fidl_next::Message<___T>,
18415        responder: ::fidl_next::protocol::Responder<___T>,
18416    ) -> ::core::result::Result<
18417        (),
18418        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18419    > {
18420        match *message.header().ordinal {
18421            268639596268373415 => {
18422                let responder = ::fidl_next::Responder::from_untyped(responder);
18423
18424                handler.get_next(responder).await;
18425                Ok(())
18426            }
18427
18428            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18429        }
18430    }
18431}
18432
18433impl<___T> ExtendedAttributeIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
18434    ___T: ::fidl_next::Transport
18435{
18436}
18437
18438impl<___H, ___T> ExtendedAttributeIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
18439where
18440    ___H: ExtendedAttributeIteratorClientHandler<___T>,
18441    ___T: ::fidl_next::Transport,
18442{
18443}
18444
18445impl<___H, ___T> ExtendedAttributeIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
18446where
18447    ___H: ExtendedAttributeIteratorServerHandler<___T>,
18448    ___T: ::fidl_next::Transport,
18449{
18450    async fn get_next(
18451        &mut self,
18452
18453        responder: ::fidl_next::Responder<extended_attribute_iterator::GetNext, ___T>,
18454    ) {
18455        ___H::get_next(&mut self.0, responder).await
18456    }
18457}
18458
18459pub const FILE_PROTOCOL_NAME: &str = "fuchsia.io/File";
18460
18461#[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"]
18462pub const FLAG_TEMPORARY_AS_NOT_LINKABLE: crate::natural::Flags =
18463    crate::natural::Flags::FLAG_MUST_CREATE;
18464
18465#[doc = " The maximum I/O size that is allowed for read/write operations using\n byte vectors.\n"]
18466pub const MAX_TRANSFER_SIZE: u64 = 8192 as u64;
18467
18468/// The type corresponding to the Readable protocol.
18469#[derive(PartialEq, Debug)]
18470pub struct Readable;
18471
18472#[cfg(target_os = "fuchsia")]
18473impl ::fidl_next::HasTransport for Readable {
18474    type Transport = ::fidl_next::fuchsia::zx::Channel;
18475}
18476
18477pub mod readable {
18478    pub mod prelude {
18479        pub use crate::{
18480            Readable, ReadableClientHandler, ReadableLocalClientHandler,
18481            ReadableLocalServerHandler, ReadableServerHandler, readable,
18482        };
18483
18484        pub use crate::natural::ReadableReadRequest;
18485
18486        pub use crate::natural::ReadableReadResponse;
18487    }
18488
18489    pub struct Read;
18490
18491    impl ::fidl_next::Method for Read {
18492        const ORDINAL: u64 = 395825947633028830;
18493        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18494            ::fidl_next::protocol::Flexibility::Strict;
18495
18496        type Protocol = crate::Readable;
18497
18498        type Request = crate::wire::ReadableReadRequest;
18499    }
18500
18501    impl ::fidl_next::TwoWayMethod for Read {
18502        type Response = ::fidl_next::wire::Result<
18503            'static,
18504            crate::wire::ReadableReadResponse<'static>,
18505            ::fidl_next::wire::fuchsia::Status,
18506        >;
18507    }
18508
18509    impl<___R> ::fidl_next::Respond<___R> for Read {
18510        type Output = ::core::result::Result<
18511            crate::generic::ReadableReadResponse<___R>,
18512            ::fidl_next::never::Never,
18513        >;
18514
18515        fn respond(response: ___R) -> Self::Output {
18516            ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
18517        }
18518    }
18519
18520    impl<___R> ::fidl_next::RespondErr<___R> for Read {
18521        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18522
18523        fn respond_err(response: ___R) -> Self::Output {
18524            ::core::result::Result::Err(response)
18525        }
18526    }
18527
18528    mod ___detail {
18529        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Readable
18530        where
18531            ___T: ::fidl_next::Transport,
18532        {
18533            type Client = ReadableClient<___T>;
18534            type Server = ReadableServer<___T>;
18535        }
18536
18537        /// The client for the `Readable` protocol.
18538        #[repr(transparent)]
18539        pub struct ReadableClient<___T: ::fidl_next::Transport> {
18540            #[allow(dead_code)]
18541            client: ::fidl_next::protocol::Client<___T>,
18542        }
18543
18544        impl<___T> ReadableClient<___T>
18545        where
18546            ___T: ::fidl_next::Transport,
18547        {
18548            #[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"]
18549            pub fn read(
18550                &self,
18551
18552                count: impl ::fidl_next::Encode<
18553                    ::fidl_next::wire::Uint64,
18554                    <___T as ::fidl_next::Transport>::SendBuffer,
18555                >,
18556            ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
18557            where
18558                <___T as ::fidl_next::Transport>::SendBuffer:
18559                    ::fidl_next::encoder::InternalHandleEncoder,
18560            {
18561                self.read_with(crate::generic::ReadableReadRequest { count })
18562            }
18563
18564            #[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"]
18565            pub fn read_with<___R>(
18566                &self,
18567                request: ___R,
18568            ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
18569            where
18570                ___R: ::fidl_next::Encode<
18571                        crate::wire::ReadableReadRequest,
18572                        <___T as ::fidl_next::Transport>::SendBuffer,
18573                    >,
18574            {
18575                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18576                    395825947633028830,
18577                    <super::Read as ::fidl_next::Method>::FLEXIBILITY,
18578                    request,
18579                ))
18580            }
18581        }
18582
18583        /// The server for the `Readable` protocol.
18584        #[repr(transparent)]
18585        pub struct ReadableServer<___T: ::fidl_next::Transport> {
18586            server: ::fidl_next::protocol::Server<___T>,
18587        }
18588
18589        impl<___T> ReadableServer<___T> where ___T: ::fidl_next::Transport {}
18590    }
18591}
18592
18593#[diagnostic::on_unimplemented(
18594    note = "If {Self} implements the non-local ReadableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18595)]
18596
18597/// A client handler for the Readable protocol.
18598///
18599/// See [`Readable`] for more details.
18600pub trait ReadableLocalClientHandler<
18601    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18602    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18603>
18604{
18605}
18606
18607impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Readable
18608where
18609    ___H: ReadableLocalClientHandler<___T>,
18610    ___T: ::fidl_next::Transport,
18611{
18612    async fn on_event(
18613        handler: &mut ___H,
18614        mut message: ::fidl_next::Message<___T>,
18615    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18616        match *message.header().ordinal {
18617            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18618        }
18619    }
18620}
18621
18622#[diagnostic::on_unimplemented(
18623    note = "If {Self} implements the non-local ReadableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18624)]
18625
18626/// A server handler for the Readable protocol.
18627///
18628/// See [`Readable`] for more details.
18629pub trait ReadableLocalServerHandler<
18630    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18631    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18632>
18633{
18634    #[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"]
18635    fn read(
18636        &mut self,
18637
18638        request: ::fidl_next::Request<readable::Read, ___T>,
18639
18640        responder: ::fidl_next::Responder<readable::Read, ___T>,
18641    ) -> impl ::core::future::Future<Output = ()>;
18642}
18643
18644impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Readable
18645where
18646    ___H: ReadableLocalServerHandler<___T>,
18647    ___T: ::fidl_next::Transport,
18648    for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
18649            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18650            Constraint = (),
18651        >,
18652{
18653    async fn on_one_way(
18654        handler: &mut ___H,
18655        mut message: ::fidl_next::Message<___T>,
18656    ) -> ::core::result::Result<
18657        (),
18658        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18659    > {
18660        match *message.header().ordinal {
18661            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18662        }
18663    }
18664
18665    async fn on_two_way(
18666        handler: &mut ___H,
18667        mut message: ::fidl_next::Message<___T>,
18668        responder: ::fidl_next::protocol::Responder<___T>,
18669    ) -> ::core::result::Result<
18670        (),
18671        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18672    > {
18673        match *message.header().ordinal {
18674            395825947633028830 => {
18675                let responder = ::fidl_next::Responder::from_untyped(responder);
18676
18677                match ::fidl_next::AsDecoderExt::into_decoded(message) {
18678                    Ok(decoded) => {
18679                        handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
18680                        Ok(())
18681                    }
18682                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18683                        ordinal: 395825947633028830,
18684                        error,
18685                    }),
18686                }
18687            }
18688
18689            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18690        }
18691    }
18692}
18693
18694/// A client handler for the Readable protocol.
18695///
18696/// See [`Readable`] for more details.
18697pub trait ReadableClientHandler<
18698    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18699    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18700>
18701{
18702}
18703
18704impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Readable
18705where
18706    ___H: ReadableClientHandler<___T> + ::core::marker::Send,
18707    ___T: ::fidl_next::Transport,
18708{
18709    async fn on_event(
18710        handler: &mut ___H,
18711        mut message: ::fidl_next::Message<___T>,
18712    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18713        match *message.header().ordinal {
18714            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18715        }
18716    }
18717}
18718
18719/// A server handler for the Readable protocol.
18720///
18721/// See [`Readable`] for more details.
18722pub trait ReadableServerHandler<
18723    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18724    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18725>
18726{
18727    #[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"]
18728    fn read(
18729        &mut self,
18730
18731        request: ::fidl_next::Request<readable::Read, ___T>,
18732
18733        responder: ::fidl_next::Responder<readable::Read, ___T>,
18734    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
18735}
18736
18737impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Readable
18738where
18739    ___H: ReadableServerHandler<___T> + ::core::marker::Send,
18740    ___T: ::fidl_next::Transport,
18741    for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
18742            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
18743            Constraint = (),
18744        >,
18745{
18746    async fn on_one_way(
18747        handler: &mut ___H,
18748        mut message: ::fidl_next::Message<___T>,
18749    ) -> ::core::result::Result<
18750        (),
18751        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18752    > {
18753        match *message.header().ordinal {
18754            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18755        }
18756    }
18757
18758    async fn on_two_way(
18759        handler: &mut ___H,
18760        mut message: ::fidl_next::Message<___T>,
18761        responder: ::fidl_next::protocol::Responder<___T>,
18762    ) -> ::core::result::Result<
18763        (),
18764        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
18765    > {
18766        match *message.header().ordinal {
18767            395825947633028830 => {
18768                let responder = ::fidl_next::Responder::from_untyped(responder);
18769
18770                match ::fidl_next::AsDecoderExt::into_decoded(message) {
18771                    Ok(decoded) => {
18772                        handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
18773                        Ok(())
18774                    }
18775                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
18776                        ordinal: 395825947633028830,
18777                        error,
18778                    }),
18779                }
18780            }
18781
18782            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18783        }
18784    }
18785}
18786
18787impl<___T> ReadableClientHandler<___T> for ::fidl_next::IgnoreEvents where
18788    ___T: ::fidl_next::Transport
18789{
18790}
18791
18792impl<___H, ___T> ReadableLocalClientHandler<___T> for ::fidl_next::Local<___H>
18793where
18794    ___H: ReadableClientHandler<___T>,
18795    ___T: ::fidl_next::Transport,
18796{
18797}
18798
18799impl<___H, ___T> ReadableLocalServerHandler<___T> for ::fidl_next::Local<___H>
18800where
18801    ___H: ReadableServerHandler<___T>,
18802    ___T: ::fidl_next::Transport,
18803{
18804    async fn read(
18805        &mut self,
18806
18807        request: ::fidl_next::Request<readable::Read, ___T>,
18808
18809        responder: ::fidl_next::Responder<readable::Read, ___T>,
18810    ) {
18811        ___H::read(&mut self.0, request, responder).await
18812    }
18813}
18814
18815/// The type corresponding to the Writable protocol.
18816#[derive(PartialEq, Debug)]
18817pub struct Writable;
18818
18819#[cfg(target_os = "fuchsia")]
18820impl ::fidl_next::HasTransport for Writable {
18821    type Transport = ::fidl_next::fuchsia::zx::Channel;
18822}
18823
18824pub mod writable {
18825    pub mod prelude {
18826        pub use crate::{
18827            Writable, WritableClientHandler, WritableLocalClientHandler,
18828            WritableLocalServerHandler, WritableServerHandler, writable,
18829        };
18830
18831        pub use crate::natural::WritableWriteRequest;
18832
18833        pub use crate::natural::WritableWriteResponse;
18834    }
18835
18836    pub struct Write;
18837
18838    impl ::fidl_next::Method for Write {
18839        const ORDINAL: u64 = 7651971425397809026;
18840        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18841            ::fidl_next::protocol::Flexibility::Strict;
18842
18843        type Protocol = crate::Writable;
18844
18845        type Request = crate::wire::WritableWriteRequest<'static>;
18846    }
18847
18848    impl ::fidl_next::TwoWayMethod for Write {
18849        type Response = ::fidl_next::wire::Result<
18850            'static,
18851            crate::wire::WritableWriteResponse,
18852            ::fidl_next::wire::fuchsia::Status,
18853        >;
18854    }
18855
18856    impl<___R> ::fidl_next::Respond<___R> for Write {
18857        type Output = ::core::result::Result<
18858            crate::generic::WritableWriteResponse<___R>,
18859            ::fidl_next::never::Never,
18860        >;
18861
18862        fn respond(response: ___R) -> Self::Output {
18863            ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
18864                actual_count: response,
18865            })
18866        }
18867    }
18868
18869    impl<___R> ::fidl_next::RespondErr<___R> for Write {
18870        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18871
18872        fn respond_err(response: ___R) -> Self::Output {
18873            ::core::result::Result::Err(response)
18874        }
18875    }
18876
18877    mod ___detail {
18878        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Writable
18879        where
18880            ___T: ::fidl_next::Transport,
18881        {
18882            type Client = WritableClient<___T>;
18883            type Server = WritableServer<___T>;
18884        }
18885
18886        /// The client for the `Writable` protocol.
18887        #[repr(transparent)]
18888        pub struct WritableClient<___T: ::fidl_next::Transport> {
18889            #[allow(dead_code)]
18890            client: ::fidl_next::protocol::Client<___T>,
18891        }
18892
18893        impl<___T> WritableClient<___T>
18894        where
18895            ___T: ::fidl_next::Transport,
18896        {
18897            #[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"]
18898            pub fn write(
18899                &self,
18900
18901                data: impl ::fidl_next::Encode<
18902                    ::fidl_next::wire::Vector<'static, u8>,
18903                    <___T as ::fidl_next::Transport>::SendBuffer,
18904                >,
18905            ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
18906            where
18907                <___T as ::fidl_next::Transport>::SendBuffer:
18908                    ::fidl_next::encoder::InternalHandleEncoder,
18909                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18910            {
18911                self.write_with(crate::generic::WritableWriteRequest { data })
18912            }
18913
18914            #[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"]
18915            pub fn write_with<___R>(
18916                &self,
18917                request: ___R,
18918            ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
18919            where
18920                ___R: ::fidl_next::Encode<
18921                        crate::wire::WritableWriteRequest<'static>,
18922                        <___T as ::fidl_next::Transport>::SendBuffer,
18923                    >,
18924            {
18925                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18926                    7651971425397809026,
18927                    <super::Write as ::fidl_next::Method>::FLEXIBILITY,
18928                    request,
18929                ))
18930            }
18931        }
18932
18933        /// The server for the `Writable` protocol.
18934        #[repr(transparent)]
18935        pub struct WritableServer<___T: ::fidl_next::Transport> {
18936            server: ::fidl_next::protocol::Server<___T>,
18937        }
18938
18939        impl<___T> WritableServer<___T> where ___T: ::fidl_next::Transport {}
18940    }
18941}
18942
18943#[diagnostic::on_unimplemented(
18944    note = "If {Self} implements the non-local WritableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
18945)]
18946
18947/// A client handler for the Writable protocol.
18948///
18949/// See [`Writable`] for more details.
18950pub trait WritableLocalClientHandler<
18951    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18952    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18953>
18954{
18955}
18956
18957impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Writable
18958where
18959    ___H: WritableLocalClientHandler<___T>,
18960    ___T: ::fidl_next::Transport,
18961{
18962    async fn on_event(
18963        handler: &mut ___H,
18964        mut message: ::fidl_next::Message<___T>,
18965    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
18966        match *message.header().ordinal {
18967            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
18968        }
18969    }
18970}
18971
18972#[diagnostic::on_unimplemented(
18973    note = "If {Self} implements the non-local WritableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
18974)]
18975
18976/// A server handler for the Writable protocol.
18977///
18978/// See [`Writable`] for more details.
18979pub trait WritableLocalServerHandler<
18980    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
18981    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
18982>
18983{
18984    #[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"]
18985    fn write(
18986        &mut self,
18987
18988        request: ::fidl_next::Request<writable::Write, ___T>,
18989
18990        responder: ::fidl_next::Responder<writable::Write, ___T>,
18991    ) -> impl ::core::future::Future<Output = ()>;
18992}
18993
18994impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Writable
18995where
18996    ___H: WritableLocalServerHandler<___T>,
18997    ___T: ::fidl_next::Transport,
18998    for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
18999            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19000            Constraint = (),
19001        >,
19002{
19003    async fn on_one_way(
19004        handler: &mut ___H,
19005        mut message: ::fidl_next::Message<___T>,
19006    ) -> ::core::result::Result<
19007        (),
19008        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19009    > {
19010        match *message.header().ordinal {
19011            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19012        }
19013    }
19014
19015    async fn on_two_way(
19016        handler: &mut ___H,
19017        mut message: ::fidl_next::Message<___T>,
19018        responder: ::fidl_next::protocol::Responder<___T>,
19019    ) -> ::core::result::Result<
19020        (),
19021        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19022    > {
19023        match *message.header().ordinal {
19024            7651971425397809026 => {
19025                let responder = ::fidl_next::Responder::from_untyped(responder);
19026
19027                match ::fidl_next::AsDecoderExt::into_decoded(message) {
19028                    Ok(decoded) => {
19029                        handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
19030                        Ok(())
19031                    }
19032                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19033                        ordinal: 7651971425397809026,
19034                        error,
19035                    }),
19036                }
19037            }
19038
19039            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19040        }
19041    }
19042}
19043
19044/// A client handler for the Writable protocol.
19045///
19046/// See [`Writable`] for more details.
19047pub trait WritableClientHandler<
19048    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19049    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19050>
19051{
19052}
19053
19054impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Writable
19055where
19056    ___H: WritableClientHandler<___T> + ::core::marker::Send,
19057    ___T: ::fidl_next::Transport,
19058{
19059    async fn on_event(
19060        handler: &mut ___H,
19061        mut message: ::fidl_next::Message<___T>,
19062    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19063        match *message.header().ordinal {
19064            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19065        }
19066    }
19067}
19068
19069/// A server handler for the Writable protocol.
19070///
19071/// See [`Writable`] for more details.
19072pub trait WritableServerHandler<
19073    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19074    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19075>
19076{
19077    #[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"]
19078    fn write(
19079        &mut self,
19080
19081        request: ::fidl_next::Request<writable::Write, ___T>,
19082
19083        responder: ::fidl_next::Responder<writable::Write, ___T>,
19084    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19085}
19086
19087impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Writable
19088where
19089    ___H: WritableServerHandler<___T> + ::core::marker::Send,
19090    ___T: ::fidl_next::Transport,
19091    for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
19092            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19093            Constraint = (),
19094        >,
19095{
19096    async fn on_one_way(
19097        handler: &mut ___H,
19098        mut message: ::fidl_next::Message<___T>,
19099    ) -> ::core::result::Result<
19100        (),
19101        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19102    > {
19103        match *message.header().ordinal {
19104            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19105        }
19106    }
19107
19108    async fn on_two_way(
19109        handler: &mut ___H,
19110        mut message: ::fidl_next::Message<___T>,
19111        responder: ::fidl_next::protocol::Responder<___T>,
19112    ) -> ::core::result::Result<
19113        (),
19114        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19115    > {
19116        match *message.header().ordinal {
19117            7651971425397809026 => {
19118                let responder = ::fidl_next::Responder::from_untyped(responder);
19119
19120                match ::fidl_next::AsDecoderExt::into_decoded(message) {
19121                    Ok(decoded) => {
19122                        handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
19123                        Ok(())
19124                    }
19125                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19126                        ordinal: 7651971425397809026,
19127                        error,
19128                    }),
19129                }
19130            }
19131
19132            ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
19133        }
19134    }
19135}
19136
19137impl<___T> WritableClientHandler<___T> for ::fidl_next::IgnoreEvents where
19138    ___T: ::fidl_next::Transport
19139{
19140}
19141
19142impl<___H, ___T> WritableLocalClientHandler<___T> for ::fidl_next::Local<___H>
19143where
19144    ___H: WritableClientHandler<___T>,
19145    ___T: ::fidl_next::Transport,
19146{
19147}
19148
19149impl<___H, ___T> WritableLocalServerHandler<___T> for ::fidl_next::Local<___H>
19150where
19151    ___H: WritableServerHandler<___T>,
19152    ___T: ::fidl_next::Transport,
19153{
19154    async fn write(
19155        &mut self,
19156
19157        request: ::fidl_next::Request<writable::Write, ___T>,
19158
19159        responder: ::fidl_next::Responder<writable::Write, ___T>,
19160    ) {
19161        ___H::write(&mut self.0, request, responder).await
19162    }
19163}
19164
19165pub const MAX_FS_NAME_BUFFER: u64 = 32 as u64;
19166
19167#[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"]
19168pub const INHERITED_WRITE_PERMISSIONS: crate::natural::Operations =
19169    crate::natural::Operations::from_bits_retain(356);
19170
19171#[doc = " Nodes which do not have ino values should return this value\n from Readdir and GetAttr.\n"]
19172pub const INO_UNKNOWN: u64 = 18446744073709551615 as u64;
19173
19174pub const MASK_KNOWN_PERMISSIONS: crate::natural::Flags =
19175    crate::natural::Flags::from_bits_retain(25087);
19176
19177pub const MASK_KNOWN_PROTOCOLS: crate::natural::Flags =
19178    crate::natural::Flags::from_bits_retain(30069489664);
19179
19180pub const MASK_PERMISSION_FLAGS: u64 = 65535 as u64;
19181
19182pub const MASK_POSIX_FLAGS: u64 = 4294967295 as u64;
19183
19184#[doc = " The maximum length, in bytes, of a single filesystem component.\n"]
19185pub const MAX_FILENAME: u64 = 255 as u64;
19186
19187pub const NODE_PROTOCOL_NAME: &str = "fuchsia.io/Node";
19188
19189#[doc = " Flags used when opening a node reference must fall within this mask.\n"]
19190pub const OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE: crate::natural::OpenFlags =
19191    crate::natural::OpenFlags::from_bits_retain(46661632);
19192
19193#[doc = " All known rights.\n"]
19194pub const OPEN_RIGHTS: crate::natural::OpenFlags = crate::natural::OpenFlags::from_bits_retain(11);
19195
19196#[doc = " Set of permissions that are expected when opening a node as executable.\n"]
19197pub const PERM_EXECUTABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(201);
19198
19199#[doc = " Set of permissions that are expected when opening a node as readable.\n"]
19200pub const PERM_READABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(211);
19201
19202#[doc = " Set of permissions that are expected when opening a node as writable.\n"]
19203pub const PERM_WRITABLE: crate::natural::Flags = crate::natural::Flags::from_bits_retain(485);
19204
19205#[doc = " Alias for directory permission alias rw*\n"]
19206pub const RW_STAR_DIR: crate::natural::Operations =
19207    crate::natural::Operations::from_bits_retain(503);
19208
19209#[doc = " Alias for directory permission alias rx*\n"]
19210pub const RX_STAR_DIR: crate::natural::Operations =
19211    crate::natural::Operations::from_bits_retain(219);
19212
19213#[doc = " Alias for directory permission alias r*\n"]
19214pub const R_STAR_DIR: crate::natural::Operations =
19215    crate::natural::Operations::from_bits_retain(211);
19216
19217#[doc = " The name of the extended attribute accessible via the SELinux context attribute.\n"]
19218pub const SELINUX_CONTEXT_NAME: &str = "security.selinux";
19219
19220pub const SYMLINK_PROTOCOL_NAME: &str = "fuchsia.io/Symlink";
19221
19222#[doc = " Alias for directory permission alias w*\n"]
19223pub const W_STAR_DIR: crate::natural::Operations =
19224    crate::natural::Operations::from_bits_retain(485);
19225
19226#[doc = " Alias for directory permission alias x*\n"]
19227pub const X_STAR_DIR: crate::natural::Operations =
19228    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
