1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_io::natural::*;
8
9 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
10 pub struct ConnectionInfo {
11 pub rights: ::core::option::Option<crate::natural::Operations>,
12 }
13
14 impl ConnectionInfo {
15 fn __max_ordinal(&self) -> usize {
16 if self.rights.is_some() {
17 return 1;
18 }
19
20 0
21 }
22 }
23
24 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ConnectionInfo<'static>, ___E> for ConnectionInfo
25 where
26 ___E: ::fidl_next::Encoder + ?Sized,
27 ___E: ::fidl_next::fuchsia::HandleEncoder,
28 {
29 #[inline]
30 fn encode(
31 mut self,
32 encoder: &mut ___E,
33 out: &mut ::core::mem::MaybeUninit<crate::wire::ConnectionInfo<'static>>,
34 _: (),
35 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
36 ::fidl_next::munge!(let crate::wire::ConnectionInfo { table } = out);
37
38 let max_ord = self.__max_ordinal();
39
40 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
41 ::fidl_next::Wire::zero_padding(&mut out);
42
43 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
44 ::fidl_next::wire::Envelope,
45 >(encoder, max_ord);
46
47 for i in 1..=max_ord {
48 match i {
49 1 => {
50 if let Some(value) = self.rights.take() {
51 ::fidl_next::wire::Envelope::encode_value::<
52 crate::wire::Operations,
53 ___E,
54 >(
55 value, preallocated.encoder, &mut out, ()
56 )?;
57 } else {
58 ::fidl_next::wire::Envelope::encode_zero(&mut out)
59 }
60 }
61
62 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
63 }
64 unsafe {
65 preallocated.write_next(out.assume_init_ref());
66 }
67 }
68
69 ::fidl_next::wire::Table::encode_len(table, max_ord);
70
71 Ok(())
72 }
73 }
74
75 impl<'de> ::fidl_next::FromWire<crate::wire::ConnectionInfo<'de>> for ConnectionInfo {
76 #[inline]
77 fn from_wire(wire_: crate::wire::ConnectionInfo<'de>) -> Self {
78 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
79
80 let rights = wire_.table.get(1);
81
82 Self {
83 rights: rights.map(|envelope| {
84 ::fidl_next::FromWire::from_wire(unsafe {
85 envelope.read_unchecked::<crate::wire::Operations>()
86 })
87 }),
88 }
89 }
90 }
91
92 #[derive(Debug, PartialEq)]
93 pub struct DirectoryLinkRequest {
94 pub src: ::std::string::String,
95
96 pub dst_parent_token: ::fidl_next::fuchsia::zx::NullableHandle,
97
98 pub dst: ::std::string::String,
99 }
100
101 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
102 for DirectoryLinkRequest
103 where
104 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
105 ___E: ::fidl_next::Encoder,
106 ___E: ::fidl_next::fuchsia::HandleEncoder,
107 {
108 #[inline]
109 fn encode(
110 self,
111 encoder_: &mut ___E,
112 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
113 _: (),
114 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
115 ::fidl_next::munge! {
116 let crate::wire::DirectoryLinkRequest {
117 src,
118 dst_parent_token,
119 dst,
120
121 } = out_;
122 }
123
124 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
125
126 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
127 ::fidl_next::Constrained::validate(_field, 255)?;
128
129 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
130
131 let mut _field =
132 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
133
134 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
135
136 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
137 ::fidl_next::Constrained::validate(_field, 255)?;
138
139 Ok(())
140 }
141 }
142
143 unsafe impl<___E>
144 ::fidl_next::EncodeOption<
145 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
146 ___E,
147 > for DirectoryLinkRequest
148 where
149 ___E: ::fidl_next::Encoder + ?Sized,
150 DirectoryLinkRequest: ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>,
151 {
152 #[inline]
153 fn encode_option(
154 this: ::core::option::Option<Self>,
155 encoder: &mut ___E,
156 out: &mut ::core::mem::MaybeUninit<
157 ::fidl_next::wire::Box<'static, crate::wire::DirectoryLinkRequest<'static>>,
158 >,
159 _: (),
160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
161 if let Some(inner) = this {
162 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
163 ::fidl_next::wire::Box::encode_present(out);
164 } else {
165 ::fidl_next::wire::Box::encode_absent(out);
166 }
167
168 Ok(())
169 }
170 }
171
172 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryLinkRequest<'de>> for DirectoryLinkRequest {
173 #[inline]
174 fn from_wire(wire: crate::wire::DirectoryLinkRequest<'de>) -> Self {
175 Self {
176 src: ::fidl_next::FromWire::from_wire(wire.src),
177
178 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
179
180 dst: ::fidl_next::FromWire::from_wire(wire.dst),
181 }
182 }
183 }
184
185 #[doc = " The type to identify a connection to a node.\n It represents a capability: a reference to a node with associated rights.\n"]
186 pub type Token = ::fidl_next::fuchsia::zx::Event;
187
188 #[derive(Debug, PartialEq)]
189 pub struct DirectoryRenameRequest {
190 pub src: ::std::string::String,
191
192 pub dst_parent_token: ::fidl_next::fuchsia::zx::Event,
193
194 pub dst: ::std::string::String,
195 }
196
197 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
198 for DirectoryRenameRequest
199 where
200 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
201 ___E: ::fidl_next::Encoder,
202 ___E: ::fidl_next::fuchsia::HandleEncoder,
203 {
204 #[inline]
205 fn encode(
206 self,
207 encoder_: &mut ___E,
208 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
209 _: (),
210 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
211 ::fidl_next::munge! {
212 let crate::wire::DirectoryRenameRequest {
213 src,
214 dst_parent_token,
215 dst,
216
217 } = out_;
218 }
219
220 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
221
222 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(src.as_mut_ptr()) };
223 ::fidl_next::Constrained::validate(_field, 255)?;
224
225 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
226
227 let mut _field =
228 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
229
230 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
231
232 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
233 ::fidl_next::Constrained::validate(_field, 255)?;
234
235 Ok(())
236 }
237 }
238
239 unsafe impl<___E>
240 ::fidl_next::EncodeOption<
241 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
242 ___E,
243 > for DirectoryRenameRequest
244 where
245 ___E: ::fidl_next::Encoder + ?Sized,
246 DirectoryRenameRequest:
247 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>,
248 {
249 #[inline]
250 fn encode_option(
251 this: ::core::option::Option<Self>,
252 encoder: &mut ___E,
253 out: &mut ::core::mem::MaybeUninit<
254 ::fidl_next::wire::Box<'static, crate::wire::DirectoryRenameRequest<'static>>,
255 >,
256 _: (),
257 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
258 if let Some(inner) = this {
259 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
260 ::fidl_next::wire::Box::encode_present(out);
261 } else {
262 ::fidl_next::wire::Box::encode_absent(out);
263 }
264
265 Ok(())
266 }
267 }
268
269 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryRenameRequest<'de>>
270 for DirectoryRenameRequest
271 {
272 #[inline]
273 fn from_wire(wire: crate::wire::DirectoryRenameRequest<'de>) -> Self {
274 Self {
275 src: ::fidl_next::FromWire::from_wire(wire.src),
276
277 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
278
279 dst: ::fidl_next::FromWire::from_wire(wire.dst),
280 }
281 }
282 }
283
284 #[derive(Debug, PartialEq)]
285 #[repr(C)]
286 pub struct DirectoryWatchRequest {
287 pub mask: crate::natural::WatchMask,
288
289 pub options: u32,
290
291 pub watcher:
292 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel>,
293 }
294
295 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
296 for DirectoryWatchRequest
297 where
298 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
299 ___E: ::fidl_next::fuchsia::HandleEncoder,
300 {
301 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
302 Self,
303 crate::wire::DirectoryWatchRequest,
304 > = unsafe {
305 ::fidl_next::CopyOptimization::enable_if(
306 true
307
308 && <
309 crate::natural::WatchMask as ::fidl_next::Encode<crate::wire::WatchMask, ___E>
310 >::COPY_OPTIMIZATION.is_enabled()
311
312 && <
313 u32 as ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>
314 >::COPY_OPTIMIZATION.is_enabled()
315
316 && <
317 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::fuchsia::zx::Channel> as ::fidl_next::Encode<::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::wire::fuchsia::Channel>, ___E>
318 >::COPY_OPTIMIZATION.is_enabled()
319
320 )
321 };
322
323 #[inline]
324 fn encode(
325 self,
326 encoder_: &mut ___E,
327 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
328 _: (),
329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
330 ::fidl_next::munge! {
331 let crate::wire::DirectoryWatchRequest {
332 mask,
333 options,
334 watcher,
335
336 } = out_;
337 }
338
339 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
340
341 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mask.as_mut_ptr()) };
342
343 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
344
345 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
346
347 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
348
349 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(watcher.as_mut_ptr()) };
350
351 Ok(())
352 }
353 }
354
355 unsafe impl<___E>
356 ::fidl_next::EncodeOption<
357 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
358 ___E,
359 > for DirectoryWatchRequest
360 where
361 ___E: ::fidl_next::Encoder + ?Sized,
362 DirectoryWatchRequest: ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>,
363 {
364 #[inline]
365 fn encode_option(
366 this: ::core::option::Option<Self>,
367 encoder: &mut ___E,
368 out: &mut ::core::mem::MaybeUninit<
369 ::fidl_next::wire::Box<'static, crate::wire::DirectoryWatchRequest>,
370 >,
371 _: (),
372 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
373 if let Some(inner) = this {
374 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
375 ::fidl_next::wire::Box::encode_present(out);
376 } else {
377 ::fidl_next::wire::Box::encode_absent(out);
378 }
379
380 Ok(())
381 }
382 }
383
384 impl ::fidl_next::FromWire<crate::wire::DirectoryWatchRequest> for DirectoryWatchRequest {
385 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
386 crate::wire::DirectoryWatchRequest,
387 Self,
388 > = unsafe {
389 ::fidl_next::CopyOptimization::enable_if(
390 true && <crate::natural::WatchMask as ::fidl_next::FromWire<
391 crate::wire::WatchMask,
392 >>::COPY_OPTIMIZATION
393 .is_enabled()
394 && <u32 as ::fidl_next::FromWire<::fidl_next::wire::Uint32>>::COPY_OPTIMIZATION
395 .is_enabled()
396 && <::fidl_next::ServerEnd<
397 crate::DirectoryWatcher,
398 ::fidl_next::fuchsia::zx::Channel,
399 > as ::fidl_next::FromWire<
400 ::fidl_next::ServerEnd<
401 crate::DirectoryWatcher,
402 ::fidl_next::wire::fuchsia::Channel,
403 >,
404 >>::COPY_OPTIMIZATION
405 .is_enabled(),
406 )
407 };
408
409 #[inline]
410 fn from_wire(wire: crate::wire::DirectoryWatchRequest) -> Self {
411 Self {
412 mask: ::fidl_next::FromWire::from_wire(wire.mask),
413
414 options: ::fidl_next::FromWire::from_wire(wire.options),
415
416 watcher: ::fidl_next::FromWire::from_wire(wire.watcher),
417 }
418 }
419 }
420
421 #[derive(Debug, PartialEq)]
422 #[repr(C)]
423 pub struct NodeListExtendedAttributesRequest {
424 pub iterator: ::fidl_next::ServerEnd<
425 crate::ExtendedAttributeIterator,
426 ::fidl_next::fuchsia::zx::Channel,
427 >,
428 }
429
430 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
431 for NodeListExtendedAttributesRequest
432 where
433 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
434 ___E: ::fidl_next::fuchsia::HandleEncoder,
435 {
436 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
437 Self,
438 crate::wire::NodeListExtendedAttributesRequest,
439 > = unsafe {
440 ::fidl_next::CopyOptimization::enable_if(
441 true && <::fidl_next::ServerEnd<
442 crate::ExtendedAttributeIterator,
443 ::fidl_next::fuchsia::zx::Channel,
444 > as ::fidl_next::Encode<
445 ::fidl_next::ServerEnd<
446 crate::ExtendedAttributeIterator,
447 ::fidl_next::wire::fuchsia::Channel,
448 >,
449 ___E,
450 >>::COPY_OPTIMIZATION
451 .is_enabled(),
452 )
453 };
454
455 #[inline]
456 fn encode(
457 self,
458 encoder_: &mut ___E,
459 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
460 _: (),
461 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
462 ::fidl_next::munge! {
463 let crate::wire::NodeListExtendedAttributesRequest {
464 iterator,
465
466 } = out_;
467 }
468
469 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
470
471 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
472
473 Ok(())
474 }
475 }
476
477 unsafe impl<___E>
478 ::fidl_next::EncodeOption<
479 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
480 ___E,
481 > for NodeListExtendedAttributesRequest
482 where
483 ___E: ::fidl_next::Encoder + ?Sized,
484 NodeListExtendedAttributesRequest:
485 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>,
486 {
487 #[inline]
488 fn encode_option(
489 this: ::core::option::Option<Self>,
490 encoder: &mut ___E,
491 out: &mut ::core::mem::MaybeUninit<
492 ::fidl_next::wire::Box<'static, crate::wire::NodeListExtendedAttributesRequest>,
493 >,
494 _: (),
495 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
496 if let Some(inner) = this {
497 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
498 ::fidl_next::wire::Box::encode_present(out);
499 } else {
500 ::fidl_next::wire::Box::encode_absent(out);
501 }
502
503 Ok(())
504 }
505 }
506
507 impl ::fidl_next::FromWire<crate::wire::NodeListExtendedAttributesRequest>
508 for NodeListExtendedAttributesRequest
509 {
510 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
511 crate::wire::NodeListExtendedAttributesRequest,
512 Self,
513 > = unsafe {
514 ::fidl_next::CopyOptimization::enable_if(
515 true && <::fidl_next::ServerEnd<
516 crate::ExtendedAttributeIterator,
517 ::fidl_next::fuchsia::zx::Channel,
518 > as ::fidl_next::FromWire<
519 ::fidl_next::ServerEnd<
520 crate::ExtendedAttributeIterator,
521 ::fidl_next::wire::fuchsia::Channel,
522 >,
523 >>::COPY_OPTIMIZATION
524 .is_enabled(),
525 )
526 };
527
528 #[inline]
529 fn from_wire(wire: crate::wire::NodeListExtendedAttributesRequest) -> Self {
530 Self { iterator: ::fidl_next::FromWire::from_wire(wire.iterator) }
531 }
532 }
533
534 #[doc = " The value type for an extended attribute. If the value is less than 32768\n bytes, then it is included inline. Values larger than this size are written\n into a vmo buffer.\n"]
535 #[derive(Debug, PartialEq)]
536 pub enum ExtendedAttributeValue {
537 Bytes(::std::vec::Vec<u8>),
538
539 Buffer(::fidl_next::fuchsia::zx::Vmo),
540
541 UnknownOrdinal_(u64),
542 }
543
544 impl ExtendedAttributeValue {
545 pub fn is_unknown(&self) -> bool {
546 #[allow(unreachable_patterns)]
547 match self {
548 Self::UnknownOrdinal_(_) => true,
549 _ => false,
550 }
551 }
552 }
553
554 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>
555 for ExtendedAttributeValue
556 where
557 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
558 ___E: ::fidl_next::Encoder,
559 ___E: ::fidl_next::fuchsia::HandleEncoder,
560 {
561 #[inline]
562 fn encode(
563 self,
564 encoder: &mut ___E,
565 out: &mut ::core::mem::MaybeUninit<crate::wire::ExtendedAttributeValue<'static>>,
566 _: (),
567 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
568 ::fidl_next::munge!(let crate::wire::ExtendedAttributeValue { raw, _phantom: _ } = out);
569
570 match self {
571 Self::Bytes(value) => ::fidl_next::wire::Union::encode_as::<
572 ___E,
573 ::fidl_next::wire::Vector<'static, u8>,
574 >(value, 1, encoder, raw, (32768, ()))?,
575
576 Self::Buffer(value) => ::fidl_next::wire::Union::encode_as::<
577 ___E,
578 ::fidl_next::wire::fuchsia::Vmo,
579 >(value, 2, encoder, raw, ())?,
580
581 Self::UnknownOrdinal_(ordinal) => {
582 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
583 }
584 }
585
586 Ok(())
587 }
588 }
589
590 unsafe impl<___E>
591 ::fidl_next::EncodeOption<crate::wire_optional::ExtendedAttributeValue<'static>, ___E>
592 for ExtendedAttributeValue
593 where
594 ___E: ?Sized,
595 ExtendedAttributeValue:
596 ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
597 {
598 #[inline]
599 fn encode_option(
600 this: ::core::option::Option<Self>,
601 encoder: &mut ___E,
602 out: &mut ::core::mem::MaybeUninit<
603 crate::wire_optional::ExtendedAttributeValue<'static>,
604 >,
605 _: (),
606 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
607 ::fidl_next::munge!(let crate::wire_optional::ExtendedAttributeValue { raw, _phantom: _ } = &mut *out);
608
609 if let Some(inner) = this {
610 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
611 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
612 } else {
613 ::fidl_next::wire::Union::encode_absent(raw);
614 }
615
616 Ok(())
617 }
618 }
619
620 impl<'de> ::fidl_next::FromWire<crate::wire::ExtendedAttributeValue<'de>>
621 for ExtendedAttributeValue
622 {
623 #[inline]
624 fn from_wire(wire: crate::wire::ExtendedAttributeValue<'de>) -> Self {
625 let wire = ::core::mem::ManuallyDrop::new(wire);
626 match wire.raw.ordinal() {
627 1 => Self::Bytes(::fidl_next::FromWire::from_wire(unsafe {
628 wire.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
629 })),
630
631 2 => Self::Buffer(::fidl_next::FromWire::from_wire(unsafe {
632 wire.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
633 })),
634
635 ord => return Self::UnknownOrdinal_(ord as u64),
636 }
637 }
638 }
639
640 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
641 for ExtendedAttributeValue
642 {
643 #[inline]
644 fn from_wire_option(
645 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
646 ) -> ::core::option::Option<Self> {
647 if let Some(inner) = wire.into_option() {
648 Some(::fidl_next::FromWire::from_wire(inner))
649 } else {
650 None
651 }
652 }
653 }
654
655 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::ExtendedAttributeValue<'de>>
656 for Box<ExtendedAttributeValue>
657 {
658 #[inline]
659 fn from_wire_option(
660 wire: crate::wire_optional::ExtendedAttributeValue<'de>,
661 ) -> ::core::option::Option<Self> {
662 <ExtendedAttributeValue as ::fidl_next::FromWireOption<
663 crate::wire_optional::ExtendedAttributeValue<'de>,
664 >>::from_wire_option(wire)
665 .map(Box::new)
666 }
667 }
668
669 #[derive(Debug, PartialEq)]
670 pub struct NodeSetExtendedAttributeRequest {
671 pub name: ::std::vec::Vec<u8>,
672
673 pub value: crate::natural::ExtendedAttributeValue,
674
675 pub mode: crate::natural::SetExtendedAttributeMode,
676 }
677
678 unsafe impl<___E>
679 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
680 for NodeSetExtendedAttributeRequest
681 where
682 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
683 ___E: ::fidl_next::Encoder,
684 ___E: ::fidl_next::fuchsia::HandleEncoder,
685 {
686 #[inline]
687 fn encode(
688 self,
689 encoder_: &mut ___E,
690 out_: &mut ::core::mem::MaybeUninit<
691 crate::wire::NodeSetExtendedAttributeRequest<'static>,
692 >,
693 _: (),
694 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
695 ::fidl_next::munge! {
696 let crate::wire::NodeSetExtendedAttributeRequest {
697 name,
698 value,
699 mode,
700
701 } = out_;
702 }
703
704 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
705
706 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
707 ::fidl_next::Constrained::validate(_field, (255, ()))?;
708
709 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
710
711 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(value.as_mut_ptr()) };
712
713 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
714
715 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
716
717 Ok(())
718 }
719 }
720
721 unsafe impl<___E>
722 ::fidl_next::EncodeOption<
723 ::fidl_next::wire::Box<'static, crate::wire::NodeSetExtendedAttributeRequest<'static>>,
724 ___E,
725 > for NodeSetExtendedAttributeRequest
726 where
727 ___E: ::fidl_next::Encoder + ?Sized,
728 NodeSetExtendedAttributeRequest:
729 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>,
730 {
731 #[inline]
732 fn encode_option(
733 this: ::core::option::Option<Self>,
734 encoder: &mut ___E,
735 out: &mut ::core::mem::MaybeUninit<
736 ::fidl_next::wire::Box<
737 'static,
738 crate::wire::NodeSetExtendedAttributeRequest<'static>,
739 >,
740 >,
741 _: (),
742 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
743 if let Some(inner) = this {
744 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
745 ::fidl_next::wire::Box::encode_present(out);
746 } else {
747 ::fidl_next::wire::Box::encode_absent(out);
748 }
749
750 Ok(())
751 }
752 }
753
754 impl<'de> ::fidl_next::FromWire<crate::wire::NodeSetExtendedAttributeRequest<'de>>
755 for NodeSetExtendedAttributeRequest
756 {
757 #[inline]
758 fn from_wire(wire: crate::wire::NodeSetExtendedAttributeRequest<'de>) -> Self {
759 Self {
760 name: ::fidl_next::FromWire::from_wire(wire.name),
761
762 value: ::fidl_next::FromWire::from_wire(wire.value),
763
764 mode: ::fidl_next::FromWire::from_wire(wire.mode),
765 }
766 }
767 }
768
769 #[derive(Debug, PartialEq)]
770 #[repr(C)]
771 pub struct NodeGetTokenResponse {
772 pub token: ::fidl_next::fuchsia::zx::Event,
773 }
774
775 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
776 for NodeGetTokenResponse
777 where
778 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
779 ___E: ::fidl_next::fuchsia::HandleEncoder,
780 {
781 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
782 Self,
783 crate::wire::NodeGetTokenResponse,
784 > = unsafe {
785 ::fidl_next::CopyOptimization::enable_if(
786 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
787 ::fidl_next::wire::fuchsia::Event,
788 ___E,
789 >>::COPY_OPTIMIZATION
790 .is_enabled(),
791 )
792 };
793
794 #[inline]
795 fn encode(
796 self,
797 encoder_: &mut ___E,
798 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
799 _: (),
800 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
801 ::fidl_next::munge! {
802 let crate::wire::NodeGetTokenResponse {
803 token,
804
805 } = out_;
806 }
807
808 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
809
810 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
811
812 Ok(())
813 }
814 }
815
816 unsafe impl<___E>
817 ::fidl_next::EncodeOption<
818 ::fidl_next::wire::Box<'static, crate::wire::NodeGetTokenResponse>,
819 ___E,
820 > for NodeGetTokenResponse
821 where
822 ___E: ::fidl_next::Encoder + ?Sized,
823 NodeGetTokenResponse: ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>,
824 {
825 #[inline]
826 fn encode_option(
827 this: ::core::option::Option<Self>,
828 encoder: &mut ___E,
829 out: &mut ::core::mem::MaybeUninit<
830 ::fidl_next::wire::Box<'static, crate::wire::NodeGetTokenResponse>,
831 >,
832 _: (),
833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
834 if let Some(inner) = this {
835 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
836 ::fidl_next::wire::Box::encode_present(out);
837 } else {
838 ::fidl_next::wire::Box::encode_absent(out);
839 }
840
841 Ok(())
842 }
843 }
844
845 impl ::fidl_next::FromWire<crate::wire::NodeGetTokenResponse> for NodeGetTokenResponse {
846 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
847 crate::wire::NodeGetTokenResponse,
848 Self,
849 > = unsafe {
850 ::fidl_next::CopyOptimization::enable_if(
851 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
852 ::fidl_next::wire::fuchsia::Event,
853 >>::COPY_OPTIMIZATION
854 .is_enabled(),
855 )
856 };
857
858 #[inline]
859 fn from_wire(wire: crate::wire::NodeGetTokenResponse) -> Self {
860 Self { token: ::fidl_next::FromWire::from_wire(wire.token) }
861 }
862 }
863
864 #[derive(Debug, PartialEq)]
865 #[repr(C)]
866 pub struct DirectoryDeprecatedGetTokenResponse {
867 pub s: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
868
869 pub token: ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle>,
870 }
871
872 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
873 for DirectoryDeprecatedGetTokenResponse
874 where
875 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
876 ___E: ::fidl_next::fuchsia::HandleEncoder,
877 {
878 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
879 Self,
880 crate::wire::DirectoryDeprecatedGetTokenResponse,
881 > = unsafe {
882 ::fidl_next::CopyOptimization::enable_if(
883 true
884
885 && <
886 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>
887 >::COPY_OPTIMIZATION.is_enabled()
888
889 && <
890 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>
891 >::COPY_OPTIMIZATION.is_enabled()
892
893 )
894 };
895
896 #[inline]
897 fn encode(
898 self,
899 encoder_: &mut ___E,
900 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
901 _: (),
902 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
903 ::fidl_next::munge! {
904 let crate::wire::DirectoryDeprecatedGetTokenResponse {
905 s,
906 token,
907
908 } = out_;
909 }
910
911 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
912
913 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
914
915 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
916
917 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(token.as_mut_ptr()) };
918
919 Ok(())
920 }
921 }
922
923 unsafe impl<___E>
924 ::fidl_next::EncodeOption<
925 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedGetTokenResponse>,
926 ___E,
927 > for DirectoryDeprecatedGetTokenResponse
928 where
929 ___E: ::fidl_next::Encoder + ?Sized,
930 DirectoryDeprecatedGetTokenResponse:
931 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>,
932 {
933 #[inline]
934 fn encode_option(
935 this: ::core::option::Option<Self>,
936 encoder: &mut ___E,
937 out: &mut ::core::mem::MaybeUninit<
938 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedGetTokenResponse>,
939 >,
940 _: (),
941 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
942 if let Some(inner) = this {
943 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
944 ::fidl_next::wire::Box::encode_present(out);
945 } else {
946 ::fidl_next::wire::Box::encode_absent(out);
947 }
948
949 Ok(())
950 }
951 }
952
953 impl ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedGetTokenResponse>
954 for DirectoryDeprecatedGetTokenResponse
955 {
956 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
957 crate::wire::DirectoryDeprecatedGetTokenResponse,
958 Self,
959 > = unsafe {
960 ::fidl_next::CopyOptimization::enable_if(
961 true
962
963 && <
964 ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::StatusResult>
965 >::COPY_OPTIMIZATION.is_enabled()
966
967 && <
968 ::core::option::Option<::fidl_next::fuchsia::zx::NullableHandle> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalNullableHandle>
969 >::COPY_OPTIMIZATION.is_enabled()
970
971 )
972 };
973
974 #[inline]
975 fn from_wire(wire: crate::wire::DirectoryDeprecatedGetTokenResponse) -> Self {
976 Self {
977 s: ::fidl_next::FromWire::from_wire(wire.s),
978
979 token: ::fidl_next::FromWire::from_wire(wire.token),
980 }
981 }
982 }
983
984 #[doc = " Auxiliary data for the file representation of a node.\n"]
985 #[derive(Debug, Default, PartialEq)]
986 pub struct FileInfo {
987 pub is_append: ::core::option::Option<bool>,
988
989 pub observer: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
990
991 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
992
993 pub attributes: ::core::option::Option<crate::natural::NodeAttributes2>,
994 }
995
996 impl FileInfo {
997 fn __max_ordinal(&self) -> usize {
998 if self.attributes.is_some() {
999 return 4;
1000 }
1001
1002 if self.stream.is_some() {
1003 return 3;
1004 }
1005
1006 if self.observer.is_some() {
1007 return 2;
1008 }
1009
1010 if self.is_append.is_some() {
1011 return 1;
1012 }
1013
1014 0
1015 }
1016 }
1017
1018 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileInfo<'static>, ___E> for FileInfo
1019 where
1020 ___E: ::fidl_next::Encoder + ?Sized,
1021 ___E: ::fidl_next::fuchsia::HandleEncoder,
1022 {
1023 #[inline]
1024 fn encode(
1025 mut self,
1026 encoder: &mut ___E,
1027 out: &mut ::core::mem::MaybeUninit<crate::wire::FileInfo<'static>>,
1028 _: (),
1029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1030 ::fidl_next::munge!(let crate::wire::FileInfo { table } = out);
1031
1032 let max_ord = self.__max_ordinal();
1033
1034 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1035 ::fidl_next::Wire::zero_padding(&mut out);
1036
1037 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1038 ::fidl_next::wire::Envelope,
1039 >(encoder, max_ord);
1040
1041 for i in 1..=max_ord {
1042 match i {
1043 4 => {
1044 if let Some(value) = self.attributes.take() {
1045 ::fidl_next::wire::Envelope::encode_value::<
1046 crate::wire::NodeAttributes2<'static>,
1047 ___E,
1048 >(
1049 value, preallocated.encoder, &mut out, ()
1050 )?;
1051 } else {
1052 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1053 }
1054 }
1055
1056 3 => {
1057 if let Some(value) = self.stream.take() {
1058 ::fidl_next::wire::Envelope::encode_value::<
1059 ::fidl_next::wire::fuchsia::Stream,
1060 ___E,
1061 >(
1062 value, preallocated.encoder, &mut out, ()
1063 )?;
1064 } else {
1065 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1066 }
1067 }
1068
1069 2 => {
1070 if let Some(value) = self.observer.take() {
1071 ::fidl_next::wire::Envelope::encode_value::<
1072 ::fidl_next::wire::fuchsia::Event,
1073 ___E,
1074 >(
1075 value, preallocated.encoder, &mut out, ()
1076 )?;
1077 } else {
1078 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1079 }
1080 }
1081
1082 1 => {
1083 if let Some(value) = self.is_append.take() {
1084 ::fidl_next::wire::Envelope::encode_value::<bool, ___E>(
1085 value,
1086 preallocated.encoder,
1087 &mut out,
1088 (),
1089 )?;
1090 } else {
1091 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1092 }
1093 }
1094
1095 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1096 }
1097 unsafe {
1098 preallocated.write_next(out.assume_init_ref());
1099 }
1100 }
1101
1102 ::fidl_next::wire::Table::encode_len(table, max_ord);
1103
1104 Ok(())
1105 }
1106 }
1107
1108 impl<'de> ::fidl_next::FromWire<crate::wire::FileInfo<'de>> for FileInfo {
1109 #[inline]
1110 fn from_wire(wire_: crate::wire::FileInfo<'de>) -> Self {
1111 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1112
1113 let is_append = wire_.table.get(1);
1114
1115 let observer = wire_.table.get(2);
1116
1117 let stream = wire_.table.get(3);
1118
1119 let attributes = wire_.table.get(4);
1120
1121 Self {
1122 is_append: is_append.map(|envelope| {
1123 ::fidl_next::FromWire::from_wire(unsafe { envelope.read_unchecked::<bool>() })
1124 }),
1125
1126 observer: observer.map(|envelope| {
1127 ::fidl_next::FromWire::from_wire(unsafe {
1128 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
1129 })
1130 }),
1131
1132 stream: stream.map(|envelope| {
1133 ::fidl_next::FromWire::from_wire(unsafe {
1134 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Stream>()
1135 })
1136 }),
1137
1138 attributes: attributes.map(|envelope| {
1139 ::fidl_next::FromWire::from_wire(unsafe {
1140 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
1141 })
1142 }),
1143 }
1144 }
1145 }
1146
1147 #[derive(Debug, PartialEq)]
1148 pub enum Representation {
1149 Node(crate::natural::NodeInfo),
1150
1151 Directory(crate::natural::DirectoryInfo),
1152
1153 File(crate::natural::FileInfo),
1154
1155 Symlink(crate::natural::SymlinkInfo),
1156
1157 UnknownOrdinal_(u64),
1158 }
1159
1160 impl Representation {
1161 pub fn is_unknown(&self) -> bool {
1162 #[allow(unreachable_patterns)]
1163 match self {
1164 Self::UnknownOrdinal_(_) => true,
1165 _ => false,
1166 }
1167 }
1168 }
1169
1170 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Representation<'static>, ___E> for Representation
1171 where
1172 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1173 ___E: ::fidl_next::Encoder,
1174 ___E: ::fidl_next::fuchsia::HandleEncoder,
1175 {
1176 #[inline]
1177 fn encode(
1178 self,
1179 encoder: &mut ___E,
1180 out: &mut ::core::mem::MaybeUninit<crate::wire::Representation<'static>>,
1181 _: (),
1182 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1183 ::fidl_next::munge!(let crate::wire::Representation { raw, _phantom: _ } = out);
1184
1185 match self {
1186 Self::Node(value) => ::fidl_next::wire::Union::encode_as::<
1187 ___E,
1188 crate::wire::NodeInfo<'static>,
1189 >(value, 1, encoder, raw, ())?,
1190
1191 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
1192 ___E,
1193 crate::wire::DirectoryInfo<'static>,
1194 >(value, 2, encoder, raw, ())?,
1195
1196 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
1197 ___E,
1198 crate::wire::FileInfo<'static>,
1199 >(value, 3, encoder, raw, ())?,
1200
1201 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
1202 ___E,
1203 crate::wire::SymlinkInfo<'static>,
1204 >(value, 4, encoder, raw, ())?,
1205
1206 Self::UnknownOrdinal_(ordinal) => {
1207 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1208 }
1209 }
1210
1211 Ok(())
1212 }
1213 }
1214
1215 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::Representation<'static>, ___E>
1216 for Representation
1217 where
1218 ___E: ?Sized,
1219 Representation: ::fidl_next::Encode<crate::wire::Representation<'static>, ___E>,
1220 {
1221 #[inline]
1222 fn encode_option(
1223 this: ::core::option::Option<Self>,
1224 encoder: &mut ___E,
1225 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::Representation<'static>>,
1226 _: (),
1227 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1228 ::fidl_next::munge!(let crate::wire_optional::Representation { raw, _phantom: _ } = &mut *out);
1229
1230 if let Some(inner) = this {
1231 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1232 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1233 } else {
1234 ::fidl_next::wire::Union::encode_absent(raw);
1235 }
1236
1237 Ok(())
1238 }
1239 }
1240
1241 impl<'de> ::fidl_next::FromWire<crate::wire::Representation<'de>> for Representation {
1242 #[inline]
1243 fn from_wire(wire: crate::wire::Representation<'de>) -> Self {
1244 let wire = ::core::mem::ManuallyDrop::new(wire);
1245 match wire.raw.ordinal() {
1246 1 => Self::Node(::fidl_next::FromWire::from_wire(unsafe {
1247 wire.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
1248 })),
1249
1250 2 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
1251 wire.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
1252 })),
1253
1254 3 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
1255 wire.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
1256 })),
1257
1258 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
1259 wire.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
1260 })),
1261
1262 ord => return Self::UnknownOrdinal_(ord as u64),
1263 }
1264 }
1265 }
1266
1267 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1268 for Representation
1269 {
1270 #[inline]
1271 fn from_wire_option(
1272 wire: crate::wire_optional::Representation<'de>,
1273 ) -> ::core::option::Option<Self> {
1274 if let Some(inner) = wire.into_option() {
1275 Some(::fidl_next::FromWire::from_wire(inner))
1276 } else {
1277 None
1278 }
1279 }
1280 }
1281
1282 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::Representation<'de>>
1283 for Box<Representation>
1284 {
1285 #[inline]
1286 fn from_wire_option(
1287 wire: crate::wire_optional::Representation<'de>,
1288 ) -> ::core::option::Option<Self> {
1289 <Representation as ::fidl_next::FromWireOption<
1290 crate::wire_optional::Representation<'de>,
1291 >>::from_wire_option(wire)
1292 .map(Box::new)
1293 }
1294 }
1295
1296 #[derive(Debug, PartialEq)]
1297 pub struct OpenableOpenRequest {
1298 pub path: ::std::string::String,
1299
1300 pub flags: crate::natural::Flags,
1301
1302 pub options: crate::natural::Options,
1303
1304 pub object: ::fidl_next::fuchsia::zx::Channel,
1305 }
1306
1307 unsafe impl<___E> ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
1308 for OpenableOpenRequest
1309 where
1310 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1311 ___E: ::fidl_next::Encoder,
1312 ___E: ::fidl_next::fuchsia::HandleEncoder,
1313 {
1314 #[inline]
1315 fn encode(
1316 self,
1317 encoder_: &mut ___E,
1318 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
1319 _: (),
1320 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1321 ::fidl_next::munge! {
1322 let crate::wire::OpenableOpenRequest {
1323 path,
1324 flags,
1325 options,
1326 object,
1327
1328 } = out_;
1329 }
1330
1331 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1332
1333 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1334 ::fidl_next::Constrained::validate(_field, 4095)?;
1335
1336 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1337
1338 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1339
1340 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1341
1342 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1343
1344 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1345
1346 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1347
1348 Ok(())
1349 }
1350 }
1351
1352 unsafe impl<___E>
1353 ::fidl_next::EncodeOption<
1354 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1355 ___E,
1356 > for OpenableOpenRequest
1357 where
1358 ___E: ::fidl_next::Encoder + ?Sized,
1359 OpenableOpenRequest: ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>,
1360 {
1361 #[inline]
1362 fn encode_option(
1363 this: ::core::option::Option<Self>,
1364 encoder: &mut ___E,
1365 out: &mut ::core::mem::MaybeUninit<
1366 ::fidl_next::wire::Box<'static, crate::wire::OpenableOpenRequest<'static>>,
1367 >,
1368 _: (),
1369 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1370 if let Some(inner) = this {
1371 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1372 ::fidl_next::wire::Box::encode_present(out);
1373 } else {
1374 ::fidl_next::wire::Box::encode_absent(out);
1375 }
1376
1377 Ok(())
1378 }
1379 }
1380
1381 impl<'de> ::fidl_next::FromWire<crate::wire::OpenableOpenRequest<'de>> for OpenableOpenRequest {
1382 #[inline]
1383 fn from_wire(wire: crate::wire::OpenableOpenRequest<'de>) -> Self {
1384 Self {
1385 path: ::fidl_next::FromWire::from_wire(wire.path),
1386
1387 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1388
1389 options: ::fidl_next::FromWire::from_wire(wire.options),
1390
1391 object: ::fidl_next::FromWire::from_wire(wire.object),
1392 }
1393 }
1394 }
1395
1396 #[derive(Debug, PartialEq)]
1397 pub struct NodeOnOpenRequest {
1398 pub s: ::core::result::Result<(), ::fidl_next::fuchsia::zx::Status>,
1399
1400 pub info: ::core::option::Option<::std::boxed::Box<crate::natural::NodeInfoDeprecated>>,
1401 }
1402
1403 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
1404 for NodeOnOpenRequest
1405 where
1406 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1407 ___E: ::fidl_next::Encoder,
1408 ___E: ::fidl_next::fuchsia::HandleEncoder,
1409 {
1410 #[inline]
1411 fn encode(
1412 self,
1413 encoder_: &mut ___E,
1414 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
1415 _: (),
1416 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1417 ::fidl_next::munge! {
1418 let crate::wire::NodeOnOpenRequest {
1419 s,
1420 info,
1421
1422 } = out_;
1423 }
1424
1425 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
1426
1427 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(s.as_mut_ptr()) };
1428
1429 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
1430
1431 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(info.as_mut_ptr()) };
1432
1433 Ok(())
1434 }
1435 }
1436
1437 unsafe impl<___E>
1438 ::fidl_next::EncodeOption<
1439 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1440 ___E,
1441 > for NodeOnOpenRequest
1442 where
1443 ___E: ::fidl_next::Encoder + ?Sized,
1444 NodeOnOpenRequest: ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>,
1445 {
1446 #[inline]
1447 fn encode_option(
1448 this: ::core::option::Option<Self>,
1449 encoder: &mut ___E,
1450 out: &mut ::core::mem::MaybeUninit<
1451 ::fidl_next::wire::Box<'static, crate::wire::NodeOnOpenRequest<'static>>,
1452 >,
1453 _: (),
1454 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1455 if let Some(inner) = this {
1456 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1457 ::fidl_next::wire::Box::encode_present(out);
1458 } else {
1459 ::fidl_next::wire::Box::encode_absent(out);
1460 }
1461
1462 Ok(())
1463 }
1464 }
1465
1466 impl<'de> ::fidl_next::FromWire<crate::wire::NodeOnOpenRequest<'de>> for NodeOnOpenRequest {
1467 #[inline]
1468 fn from_wire(wire: crate::wire::NodeOnOpenRequest<'de>) -> Self {
1469 Self {
1470 s: ::fidl_next::FromWire::from_wire(wire.s),
1471
1472 info: ::fidl_next::FromWire::from_wire(wire.info),
1473 }
1474 }
1475 }
1476
1477 #[derive(Debug, PartialEq)]
1478 pub struct DirectoryDeprecatedOpenRequest {
1479 pub flags: crate::natural::OpenFlags,
1480
1481 pub mode: crate::natural::ModeType,
1482
1483 pub path: ::std::string::String,
1484
1485 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::fuchsia::zx::Channel>,
1486 }
1487
1488 unsafe impl<___E>
1489 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
1490 for DirectoryDeprecatedOpenRequest
1491 where
1492 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1493 ___E: ::fidl_next::Encoder,
1494 ___E: ::fidl_next::fuchsia::HandleEncoder,
1495 {
1496 #[inline]
1497 fn encode(
1498 self,
1499 encoder_: &mut ___E,
1500 out_: &mut ::core::mem::MaybeUninit<
1501 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1502 >,
1503 _: (),
1504 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1505 ::fidl_next::munge! {
1506 let crate::wire::DirectoryDeprecatedOpenRequest {
1507 flags,
1508 mode,
1509 path,
1510 object,
1511
1512 } = out_;
1513 }
1514
1515 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
1516
1517 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(flags.as_mut_ptr()) };
1518
1519 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1520
1521 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1522
1523 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1524
1525 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1526 ::fidl_next::Constrained::validate(_field, 4095)?;
1527
1528 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
1529
1530 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
1531
1532 Ok(())
1533 }
1534 }
1535
1536 unsafe impl<___E>
1537 ::fidl_next::EncodeOption<
1538 ::fidl_next::wire::Box<'static, crate::wire::DirectoryDeprecatedOpenRequest<'static>>,
1539 ___E,
1540 > for DirectoryDeprecatedOpenRequest
1541 where
1542 ___E: ::fidl_next::Encoder + ?Sized,
1543 DirectoryDeprecatedOpenRequest:
1544 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>,
1545 {
1546 #[inline]
1547 fn encode_option(
1548 this: ::core::option::Option<Self>,
1549 encoder: &mut ___E,
1550 out: &mut ::core::mem::MaybeUninit<
1551 ::fidl_next::wire::Box<
1552 'static,
1553 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
1554 >,
1555 >,
1556 _: (),
1557 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1558 if let Some(inner) = this {
1559 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1560 ::fidl_next::wire::Box::encode_present(out);
1561 } else {
1562 ::fidl_next::wire::Box::encode_absent(out);
1563 }
1564
1565 Ok(())
1566 }
1567 }
1568
1569 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryDeprecatedOpenRequest<'de>>
1570 for DirectoryDeprecatedOpenRequest
1571 {
1572 #[inline]
1573 fn from_wire(wire: crate::wire::DirectoryDeprecatedOpenRequest<'de>) -> Self {
1574 Self {
1575 flags: ::fidl_next::FromWire::from_wire(wire.flags),
1576
1577 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1578
1579 path: ::fidl_next::FromWire::from_wire(wire.path),
1580
1581 object: ::fidl_next::FromWire::from_wire(wire.object),
1582 }
1583 }
1584 }
1585
1586 #[derive(Debug, PartialEq)]
1587 pub struct DirectoryCreateSymlinkRequest {
1588 pub name: ::std::string::String,
1589
1590 pub target: ::std::vec::Vec<u8>,
1591
1592 pub connection: ::core::option::Option<
1593 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::fuchsia::zx::Channel>,
1594 >,
1595 }
1596
1597 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
1598 for DirectoryCreateSymlinkRequest
1599 where
1600 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1601 ___E: ::fidl_next::Encoder,
1602 ___E: ::fidl_next::fuchsia::HandleEncoder,
1603 {
1604 #[inline]
1605 fn encode(
1606 self,
1607 encoder_: &mut ___E,
1608 out_: &mut ::core::mem::MaybeUninit<
1609 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1610 >,
1611 _: (),
1612 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1613 ::fidl_next::munge! {
1614 let crate::wire::DirectoryCreateSymlinkRequest {
1615 name,
1616 target,
1617 connection,
1618
1619 } = out_;
1620 }
1621
1622 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
1623
1624 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(name.as_mut_ptr()) };
1625 ::fidl_next::Constrained::validate(_field, 255)?;
1626
1627 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
1628
1629 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target.as_mut_ptr()) };
1630 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
1631
1632 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
1633
1634 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(connection.as_mut_ptr()) };
1635
1636 Ok(())
1637 }
1638 }
1639
1640 unsafe impl<___E>
1641 ::fidl_next::EncodeOption<
1642 ::fidl_next::wire::Box<'static, crate::wire::DirectoryCreateSymlinkRequest<'static>>,
1643 ___E,
1644 > for DirectoryCreateSymlinkRequest
1645 where
1646 ___E: ::fidl_next::Encoder + ?Sized,
1647 DirectoryCreateSymlinkRequest:
1648 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>,
1649 {
1650 #[inline]
1651 fn encode_option(
1652 this: ::core::option::Option<Self>,
1653 encoder: &mut ___E,
1654 out: &mut ::core::mem::MaybeUninit<
1655 ::fidl_next::wire::Box<
1656 'static,
1657 crate::wire::DirectoryCreateSymlinkRequest<'static>,
1658 >,
1659 >,
1660 _: (),
1661 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1662 if let Some(inner) = this {
1663 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1664 ::fidl_next::wire::Box::encode_present(out);
1665 } else {
1666 ::fidl_next::wire::Box::encode_absent(out);
1667 }
1668
1669 Ok(())
1670 }
1671 }
1672
1673 impl<'de> ::fidl_next::FromWire<crate::wire::DirectoryCreateSymlinkRequest<'de>>
1674 for DirectoryCreateSymlinkRequest
1675 {
1676 #[inline]
1677 fn from_wire(wire: crate::wire::DirectoryCreateSymlinkRequest<'de>) -> Self {
1678 Self {
1679 name: ::fidl_next::FromWire::from_wire(wire.name),
1680
1681 target: ::fidl_next::FromWire::from_wire(wire.target),
1682
1683 connection: ::fidl_next::FromWire::from_wire(wire.connection),
1684 }
1685 }
1686 }
1687
1688 #[derive(Debug, PartialEq)]
1689 #[repr(C)]
1690 pub struct FileGetBackingMemoryResponse {
1691 pub vmo: ::fidl_next::fuchsia::zx::Vmo,
1692 }
1693
1694 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
1695 for FileGetBackingMemoryResponse
1696 where
1697 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1698 ___E: ::fidl_next::fuchsia::HandleEncoder,
1699 {
1700 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1701 Self,
1702 crate::wire::FileGetBackingMemoryResponse,
1703 > = unsafe {
1704 ::fidl_next::CopyOptimization::enable_if(
1705 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::Encode<
1706 ::fidl_next::wire::fuchsia::Vmo,
1707 ___E,
1708 >>::COPY_OPTIMIZATION
1709 .is_enabled(),
1710 )
1711 };
1712
1713 #[inline]
1714 fn encode(
1715 self,
1716 encoder_: &mut ___E,
1717 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
1718 _: (),
1719 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1720 ::fidl_next::munge! {
1721 let crate::wire::FileGetBackingMemoryResponse {
1722 vmo,
1723
1724 } = out_;
1725 }
1726
1727 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
1728
1729 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(vmo.as_mut_ptr()) };
1730
1731 Ok(())
1732 }
1733 }
1734
1735 unsafe impl<___E>
1736 ::fidl_next::EncodeOption<
1737 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1738 ___E,
1739 > for FileGetBackingMemoryResponse
1740 where
1741 ___E: ::fidl_next::Encoder + ?Sized,
1742 FileGetBackingMemoryResponse:
1743 ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>,
1744 {
1745 #[inline]
1746 fn encode_option(
1747 this: ::core::option::Option<Self>,
1748 encoder: &mut ___E,
1749 out: &mut ::core::mem::MaybeUninit<
1750 ::fidl_next::wire::Box<'static, crate::wire::FileGetBackingMemoryResponse>,
1751 >,
1752 _: (),
1753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1754 if let Some(inner) = this {
1755 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1756 ::fidl_next::wire::Box::encode_present(out);
1757 } else {
1758 ::fidl_next::wire::Box::encode_absent(out);
1759 }
1760
1761 Ok(())
1762 }
1763 }
1764
1765 impl ::fidl_next::FromWire<crate::wire::FileGetBackingMemoryResponse>
1766 for FileGetBackingMemoryResponse
1767 {
1768 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1769 crate::wire::FileGetBackingMemoryResponse,
1770 Self,
1771 > = unsafe {
1772 ::fidl_next::CopyOptimization::enable_if(
1773 true && <::fidl_next::fuchsia::zx::Vmo as ::fidl_next::FromWire<
1774 ::fidl_next::wire::fuchsia::Vmo,
1775 >>::COPY_OPTIMIZATION
1776 .is_enabled(),
1777 )
1778 };
1779
1780 #[inline]
1781 fn from_wire(wire: crate::wire::FileGetBackingMemoryResponse) -> Self {
1782 Self { vmo: ::fidl_next::FromWire::from_wire(wire.vmo) }
1783 }
1784 }
1785
1786 #[derive(Debug, PartialEq)]
1787 pub struct LinkableLinkIntoRequest {
1788 pub dst_parent_token: ::fidl_next::fuchsia::zx::Event,
1789
1790 pub dst: ::std::string::String,
1791 }
1792
1793 unsafe impl<___E> ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
1794 for LinkableLinkIntoRequest
1795 where
1796 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1797 ___E: ::fidl_next::Encoder,
1798 ___E: ::fidl_next::fuchsia::HandleEncoder,
1799 {
1800 #[inline]
1801 fn encode(
1802 self,
1803 encoder_: &mut ___E,
1804 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
1805 _: (),
1806 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1807 ::fidl_next::munge! {
1808 let crate::wire::LinkableLinkIntoRequest {
1809 dst_parent_token,
1810 dst,
1811
1812 } = out_;
1813 }
1814
1815 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
1816
1817 let mut _field =
1818 unsafe { ::fidl_next::Slot::new_unchecked(dst_parent_token.as_mut_ptr()) };
1819
1820 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
1821
1822 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dst.as_mut_ptr()) };
1823 ::fidl_next::Constrained::validate(_field, 255)?;
1824
1825 Ok(())
1826 }
1827 }
1828
1829 unsafe impl<___E>
1830 ::fidl_next::EncodeOption<
1831 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1832 ___E,
1833 > for LinkableLinkIntoRequest
1834 where
1835 ___E: ::fidl_next::Encoder + ?Sized,
1836 LinkableLinkIntoRequest:
1837 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>,
1838 {
1839 #[inline]
1840 fn encode_option(
1841 this: ::core::option::Option<Self>,
1842 encoder: &mut ___E,
1843 out: &mut ::core::mem::MaybeUninit<
1844 ::fidl_next::wire::Box<'static, crate::wire::LinkableLinkIntoRequest<'static>>,
1845 >,
1846 _: (),
1847 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1848 if let Some(inner) = this {
1849 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1850 ::fidl_next::wire::Box::encode_present(out);
1851 } else {
1852 ::fidl_next::wire::Box::encode_absent(out);
1853 }
1854
1855 Ok(())
1856 }
1857 }
1858
1859 impl<'de> ::fidl_next::FromWire<crate::wire::LinkableLinkIntoRequest<'de>>
1860 for LinkableLinkIntoRequest
1861 {
1862 #[inline]
1863 fn from_wire(wire: crate::wire::LinkableLinkIntoRequest<'de>) -> Self {
1864 Self {
1865 dst_parent_token: ::fidl_next::FromWire::from_wire(wire.dst_parent_token),
1866
1867 dst: ::fidl_next::FromWire::from_wire(wire.dst),
1868 }
1869 }
1870 }
1871
1872 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1873 pub struct FileAllocateRequest {
1874 pub offset: u64,
1875
1876 pub length: u64,
1877
1878 pub mode: crate::natural::AllocateMode,
1879 }
1880
1881 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
1882 for FileAllocateRequest
1883 where
1884 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1885 ___E: ::fidl_next::fuchsia::HandleEncoder,
1886 {
1887 #[inline]
1888 fn encode(
1889 self,
1890 encoder_: &mut ___E,
1891 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
1892 _: (),
1893 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1894 ::fidl_next::munge! {
1895 let crate::wire::FileAllocateRequest {
1896 offset,
1897 length,
1898 mode,
1899
1900 } = out_;
1901 }
1902
1903 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
1904
1905 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(offset.as_mut_ptr()) };
1906
1907 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
1908
1909 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(length.as_mut_ptr()) };
1910
1911 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
1912
1913 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(mode.as_mut_ptr()) };
1914
1915 Ok(())
1916 }
1917 }
1918
1919 unsafe impl<___E>
1920 ::fidl_next::EncodeOption<
1921 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1922 ___E,
1923 > for FileAllocateRequest
1924 where
1925 ___E: ::fidl_next::Encoder + ?Sized,
1926 FileAllocateRequest: ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>,
1927 {
1928 #[inline]
1929 fn encode_option(
1930 this: ::core::option::Option<Self>,
1931 encoder: &mut ___E,
1932 out: &mut ::core::mem::MaybeUninit<
1933 ::fidl_next::wire::Box<'static, crate::wire::FileAllocateRequest>,
1934 >,
1935 _: (),
1936 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1937 if let Some(inner) = this {
1938 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1939 ::fidl_next::wire::Box::encode_present(out);
1940 } else {
1941 ::fidl_next::wire::Box::encode_absent(out);
1942 }
1943
1944 Ok(())
1945 }
1946 }
1947
1948 impl ::fidl_next::FromWire<crate::wire::FileAllocateRequest> for FileAllocateRequest {
1949 #[inline]
1950 fn from_wire(wire: crate::wire::FileAllocateRequest) -> Self {
1951 Self {
1952 offset: ::fidl_next::FromWire::from_wire(wire.offset),
1953
1954 length: ::fidl_next::FromWire::from_wire(wire.length),
1955
1956 mode: ::fidl_next::FromWire::from_wire(wire.mode),
1957 }
1958 }
1959 }
1960
1961 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1962 pub struct FileEnableVerityRequest {
1963 pub options: crate::natural::VerificationOptions,
1964 }
1965
1966 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
1967 for FileEnableVerityRequest
1968 where
1969 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1970 ___E: ::fidl_next::Encoder,
1971 ___E: ::fidl_next::fuchsia::HandleEncoder,
1972 {
1973 #[inline]
1974 fn encode(
1975 self,
1976 encoder_: &mut ___E,
1977 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
1978 _: (),
1979 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1980 ::fidl_next::munge! {
1981 let crate::wire::FileEnableVerityRequest {
1982 options,
1983
1984 } = out_;
1985 }
1986
1987 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
1988
1989 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(options.as_mut_ptr()) };
1990
1991 Ok(())
1992 }
1993 }
1994
1995 unsafe impl<___E>
1996 ::fidl_next::EncodeOption<
1997 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
1998 ___E,
1999 > for FileEnableVerityRequest
2000 where
2001 ___E: ::fidl_next::Encoder + ?Sized,
2002 FileEnableVerityRequest:
2003 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>,
2004 {
2005 #[inline]
2006 fn encode_option(
2007 this: ::core::option::Option<Self>,
2008 encoder: &mut ___E,
2009 out: &mut ::core::mem::MaybeUninit<
2010 ::fidl_next::wire::Box<'static, crate::wire::FileEnableVerityRequest<'static>>,
2011 >,
2012 _: (),
2013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2014 if let Some(inner) = this {
2015 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2016 ::fidl_next::wire::Box::encode_present(out);
2017 } else {
2018 ::fidl_next::wire::Box::encode_absent(out);
2019 }
2020
2021 Ok(())
2022 }
2023 }
2024
2025 impl<'de> ::fidl_next::FromWire<crate::wire::FileEnableVerityRequest<'de>>
2026 for FileEnableVerityRequest
2027 {
2028 #[inline]
2029 fn from_wire(wire: crate::wire::FileEnableVerityRequest<'de>) -> Self {
2030 Self { options: ::fidl_next::FromWire::from_wire(wire.options) }
2031 }
2032 }
2033
2034 #[derive(Debug, PartialEq)]
2035 #[repr(C)]
2036 pub struct FileObject {
2037 pub event: ::core::option::Option<::fidl_next::fuchsia::zx::Event>,
2038
2039 pub stream: ::core::option::Option<::fidl_next::fuchsia::zx::Stream>,
2040 }
2041
2042 unsafe impl<___E> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject
2043 where
2044 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2045 ___E: ::fidl_next::fuchsia::HandleEncoder,
2046 {
2047 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, crate::wire::FileObject> = unsafe {
2048 ::fidl_next::CopyOptimization::enable_if(
2049 true
2050
2051 && <
2052 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>
2053 >::COPY_OPTIMIZATION.is_enabled()
2054
2055 && <
2056 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalStream, ___E>
2057 >::COPY_OPTIMIZATION.is_enabled()
2058
2059 )
2060 };
2061
2062 #[inline]
2063 fn encode(
2064 self,
2065 encoder_: &mut ___E,
2066 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
2067 _: (),
2068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2069 ::fidl_next::munge! {
2070 let crate::wire::FileObject {
2071 event,
2072 stream,
2073
2074 } = out_;
2075 }
2076
2077 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
2078
2079 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(event.as_mut_ptr()) };
2080
2081 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
2082
2083 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(stream.as_mut_ptr()) };
2084
2085 Ok(())
2086 }
2087 }
2088
2089 unsafe impl<___E>
2090 ::fidl_next::EncodeOption<::fidl_next::wire::Box<'static, crate::wire::FileObject>, ___E>
2091 for FileObject
2092 where
2093 ___E: ::fidl_next::Encoder + ?Sized,
2094 FileObject: ::fidl_next::Encode<crate::wire::FileObject, ___E>,
2095 {
2096 #[inline]
2097 fn encode_option(
2098 this: ::core::option::Option<Self>,
2099 encoder: &mut ___E,
2100 out: &mut ::core::mem::MaybeUninit<
2101 ::fidl_next::wire::Box<'static, crate::wire::FileObject>,
2102 >,
2103 _: (),
2104 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2105 if let Some(inner) = this {
2106 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2107 ::fidl_next::wire::Box::encode_present(out);
2108 } else {
2109 ::fidl_next::wire::Box::encode_absent(out);
2110 }
2111
2112 Ok(())
2113 }
2114 }
2115
2116 impl ::fidl_next::FromWire<crate::wire::FileObject> for FileObject {
2117 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<crate::wire::FileObject, Self> = unsafe {
2118 ::fidl_next::CopyOptimization::enable_if(
2119 true
2120
2121 && <
2122 ::core::option::Option<::fidl_next::fuchsia::zx::Event> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalEvent>
2123 >::COPY_OPTIMIZATION.is_enabled()
2124
2125 && <
2126 ::core::option::Option<::fidl_next::fuchsia::zx::Stream> as ::fidl_next::FromWire<::fidl_next::wire::fuchsia::OptionalStream>
2127 >::COPY_OPTIMIZATION.is_enabled()
2128
2129 )
2130 };
2131
2132 #[inline]
2133 fn from_wire(wire: crate::wire::FileObject) -> Self {
2134 Self {
2135 event: ::fidl_next::FromWire::from_wire(wire.event),
2136
2137 stream: ::fidl_next::FromWire::from_wire(wire.stream),
2138 }
2139 }
2140 }
2141
2142 #[derive(Debug, PartialEq)]
2143 pub enum NodeInfoDeprecated {
2144 Service(crate::natural::Service),
2145
2146 File(crate::natural::FileObject),
2147
2148 Directory(crate::natural::DirectoryObject),
2149
2150 Symlink(crate::natural::SymlinkObject),
2151 }
2152
2153 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>
2154 for NodeInfoDeprecated
2155 where
2156 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2157 ___E: ::fidl_next::Encoder,
2158 ___E: ::fidl_next::fuchsia::HandleEncoder,
2159 {
2160 #[inline]
2161 fn encode(
2162 self,
2163 encoder: &mut ___E,
2164 out: &mut ::core::mem::MaybeUninit<crate::wire::NodeInfoDeprecated<'static>>,
2165 _: (),
2166 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2167 ::fidl_next::munge!(let crate::wire::NodeInfoDeprecated { raw, _phantom: _ } = out);
2168
2169 match self {
2170 Self::Service(value) => ::fidl_next::wire::Union::encode_as::<
2171 ___E,
2172 crate::wire::Service,
2173 >(value, 1, encoder, raw, ())?,
2174
2175 Self::File(value) => ::fidl_next::wire::Union::encode_as::<
2176 ___E,
2177 crate::wire::FileObject,
2178 >(value, 2, encoder, raw, ())?,
2179
2180 Self::Directory(value) => ::fidl_next::wire::Union::encode_as::<
2181 ___E,
2182 crate::wire::DirectoryObject,
2183 >(value, 3, encoder, raw, ())?,
2184
2185 Self::Symlink(value) => ::fidl_next::wire::Union::encode_as::<
2186 ___E,
2187 crate::wire::SymlinkObject<'static>,
2188 >(value, 4, encoder, raw, ())?,
2189 }
2190
2191 Ok(())
2192 }
2193 }
2194
2195 unsafe impl<___E>
2196 ::fidl_next::EncodeOption<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>
2197 for NodeInfoDeprecated
2198 where
2199 ___E: ?Sized,
2200 NodeInfoDeprecated: ::fidl_next::Encode<crate::wire::NodeInfoDeprecated<'static>, ___E>,
2201 {
2202 #[inline]
2203 fn encode_option(
2204 this: ::core::option::Option<Self>,
2205 encoder: &mut ___E,
2206 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::NodeInfoDeprecated<'static>>,
2207 _: (),
2208 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2209 ::fidl_next::munge!(let crate::wire_optional::NodeInfoDeprecated { raw, _phantom: _ } = &mut *out);
2210
2211 if let Some(inner) = this {
2212 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
2213 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
2214 } else {
2215 ::fidl_next::wire::Union::encode_absent(raw);
2216 }
2217
2218 Ok(())
2219 }
2220 }
2221
2222 impl<'de> ::fidl_next::FromWire<crate::wire::NodeInfoDeprecated<'de>> for NodeInfoDeprecated {
2223 #[inline]
2224 fn from_wire(wire: crate::wire::NodeInfoDeprecated<'de>) -> Self {
2225 let wire = ::core::mem::ManuallyDrop::new(wire);
2226 match wire.raw.ordinal() {
2227 1 => Self::Service(::fidl_next::FromWire::from_wire(unsafe {
2228 wire.raw.get().read_unchecked::<crate::wire::Service>()
2229 })),
2230
2231 2 => Self::File(::fidl_next::FromWire::from_wire(unsafe {
2232 wire.raw.get().read_unchecked::<crate::wire::FileObject>()
2233 })),
2234
2235 3 => Self::Directory(::fidl_next::FromWire::from_wire(unsafe {
2236 wire.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
2237 })),
2238
2239 4 => Self::Symlink(::fidl_next::FromWire::from_wire(unsafe {
2240 wire.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
2241 })),
2242
2243 _ => unsafe { ::core::hint::unreachable_unchecked() },
2244 }
2245 }
2246 }
2247
2248 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2249 for NodeInfoDeprecated
2250 {
2251 #[inline]
2252 fn from_wire_option(
2253 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2254 ) -> ::core::option::Option<Self> {
2255 if let Some(inner) = wire.into_option() {
2256 Some(::fidl_next::FromWire::from_wire(inner))
2257 } else {
2258 None
2259 }
2260 }
2261 }
2262
2263 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::NodeInfoDeprecated<'de>>
2264 for Box<NodeInfoDeprecated>
2265 {
2266 #[inline]
2267 fn from_wire_option(
2268 wire: crate::wire_optional::NodeInfoDeprecated<'de>,
2269 ) -> ::core::option::Option<Self> {
2270 <NodeInfoDeprecated as ::fidl_next::FromWireOption<
2271 crate::wire_optional::NodeInfoDeprecated<'de>,
2272 >>::from_wire_option(wire)
2273 .map(Box::new)
2274 }
2275 }
2276}
2277
2278pub mod wire {
2279
2280 pub use fidl_next_common_fuchsia_io::wire::*;
2281
2282 #[repr(C)]
2284 pub struct ConnectionInfo<'de> {
2285 pub(crate) table: ::fidl_next::wire::Table<'de>,
2286 }
2287
2288 impl<'de> Drop for ConnectionInfo<'de> {
2289 fn drop(&mut self) {
2290 let _ = self
2291 .table
2292 .get(1)
2293 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::Operations>() });
2294 }
2295 }
2296
2297 impl ::fidl_next::Constrained for ConnectionInfo<'_> {
2298 type Constraint = ();
2299
2300 fn validate(
2301 _: ::fidl_next::Slot<'_, Self>,
2302 _: Self::Constraint,
2303 ) -> Result<(), ::fidl_next::ValidationError> {
2304 Ok(())
2305 }
2306 }
2307
2308 unsafe impl ::fidl_next::Wire for ConnectionInfo<'static> {
2309 type Narrowed<'de> = ConnectionInfo<'de>;
2310
2311 #[inline]
2312 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2313 ::fidl_next::munge!(let Self { table } = out);
2314 ::fidl_next::wire::Table::zero_padding(table);
2315 }
2316 }
2317
2318 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ConnectionInfo<'de>
2319 where
2320 ___D: ::fidl_next::Decoder<'de> + ?Sized,
2321 ___D: ::fidl_next::fuchsia::HandleDecoder,
2322 {
2323 fn decode(
2324 slot: ::fidl_next::Slot<'_, Self>,
2325 decoder: &mut ___D,
2326 _: (),
2327 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2328 ::fidl_next::munge!(let Self { table } = slot);
2329
2330 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
2331 match ordinal {
2332 0 => unsafe { ::core::hint::unreachable_unchecked() },
2333
2334 1 => {
2335 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::Operations>(
2336 slot.as_mut(),
2337 decoder,
2338 (),
2339 )?;
2340
2341 Ok(())
2342 }
2343
2344 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
2345 }
2346 })
2347 }
2348 }
2349
2350 impl<'de> ConnectionInfo<'de> {
2351 pub fn rights(&self) -> ::core::option::Option<&crate::wire::Operations> {
2352 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
2353 }
2354
2355 pub fn take_rights(&mut self) -> ::core::option::Option<crate::wire::Operations> {
2356 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
2357 }
2358 }
2359
2360 impl<'de> ::core::fmt::Debug for ConnectionInfo<'de> {
2361 fn fmt(
2362 &self,
2363 f: &mut ::core::fmt::Formatter<'_>,
2364 ) -> ::core::result::Result<(), ::core::fmt::Error> {
2365 f.debug_struct("ConnectionInfo").field("rights", &self.rights()).finish()
2366 }
2367 }
2368
2369 impl<'de> ::fidl_next::IntoNatural for ConnectionInfo<'de> {
2370 type Natural = crate::natural::ConnectionInfo;
2371 }
2372
2373 #[derive(Debug)]
2375 #[repr(C)]
2376 pub struct DirectoryLinkRequest<'de> {
2377 pub src: ::fidl_next::wire::String<'de>,
2378
2379 pub dst_parent_token: ::fidl_next::wire::fuchsia::NullableHandle,
2380
2381 pub dst: ::fidl_next::wire::String<'de>,
2382 }
2383
2384 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryLinkRequest<'_>>(), 40);
2385 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryLinkRequest<'_>>(), 8);
2386
2387 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, src), 0);
2388
2389 static_assertions::const_assert_eq!(
2390 std::mem::offset_of!(DirectoryLinkRequest<'_>, dst_parent_token),
2391 16
2392 );
2393
2394 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryLinkRequest<'_>, dst), 24);
2395
2396 impl ::fidl_next::Constrained for DirectoryLinkRequest<'_> {
2397 type Constraint = ();
2398
2399 fn validate(
2400 _: ::fidl_next::Slot<'_, Self>,
2401 _: Self::Constraint,
2402 ) -> Result<(), ::fidl_next::ValidationError> {
2403 Ok(())
2404 }
2405 }
2406
2407 unsafe impl ::fidl_next::Wire for DirectoryLinkRequest<'static> {
2408 type Narrowed<'de> = DirectoryLinkRequest<'de>;
2409
2410 #[inline]
2411 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2412 ::fidl_next::munge! {
2413 let Self {
2414 src,
2415 dst_parent_token,
2416 dst,
2417
2418 } = &mut *out_;
2419 }
2420
2421 ::fidl_next::Wire::zero_padding(src);
2422
2423 ::fidl_next::Wire::zero_padding(dst_parent_token);
2424
2425 ::fidl_next::Wire::zero_padding(dst);
2426
2427 unsafe {
2428 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2429 }
2430 }
2431 }
2432
2433 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryLinkRequest<'de>
2434 where
2435 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2436 ___D: ::fidl_next::Decoder<'de>,
2437 ___D: ::fidl_next::fuchsia::HandleDecoder,
2438 {
2439 fn decode(
2440 slot_: ::fidl_next::Slot<'_, Self>,
2441 decoder_: &mut ___D,
2442 _: (),
2443 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2444 if slot_.as_bytes()[20..24] != [0u8; 4] {
2445 return Err(::fidl_next::DecodeError::InvalidPadding);
2446 }
2447
2448 ::fidl_next::munge! {
2449 let Self {
2450 mut src,
2451 mut dst_parent_token,
2452 mut dst,
2453
2454 } = slot_;
2455 }
2456
2457 let _field = src.as_mut();
2458 ::fidl_next::Constrained::validate(_field, 255)?;
2459 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2460
2461 let src = unsafe { src.deref_unchecked() };
2462
2463 if src.len() > 255 {
2464 return Err(::fidl_next::DecodeError::VectorTooLong {
2465 size: src.len() as u64,
2466 limit: 255,
2467 });
2468 }
2469
2470 let _field = dst_parent_token.as_mut();
2471
2472 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2473
2474 let _field = dst.as_mut();
2475 ::fidl_next::Constrained::validate(_field, 255)?;
2476 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2477
2478 let dst = unsafe { dst.deref_unchecked() };
2479
2480 if dst.len() > 255 {
2481 return Err(::fidl_next::DecodeError::VectorTooLong {
2482 size: dst.len() as u64,
2483 limit: 255,
2484 });
2485 }
2486
2487 Ok(())
2488 }
2489 }
2490
2491 impl<'de> ::fidl_next::IntoNatural for DirectoryLinkRequest<'de> {
2492 type Natural = crate::natural::DirectoryLinkRequest;
2493 }
2494
2495 pub type Token = ::fidl_next::wire::fuchsia::Event;
2497
2498 #[derive(Debug)]
2500 #[repr(C)]
2501 pub struct DirectoryRenameRequest<'de> {
2502 pub src: ::fidl_next::wire::String<'de>,
2503
2504 pub dst_parent_token: ::fidl_next::wire::fuchsia::Event,
2505
2506 pub dst: ::fidl_next::wire::String<'de>,
2507 }
2508
2509 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryRenameRequest<'_>>(), 40);
2510 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryRenameRequest<'_>>(), 8);
2511
2512 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, src), 0);
2513
2514 static_assertions::const_assert_eq!(
2515 std::mem::offset_of!(DirectoryRenameRequest<'_>, dst_parent_token),
2516 16
2517 );
2518
2519 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryRenameRequest<'_>, dst), 24);
2520
2521 impl ::fidl_next::Constrained for DirectoryRenameRequest<'_> {
2522 type Constraint = ();
2523
2524 fn validate(
2525 _: ::fidl_next::Slot<'_, Self>,
2526 _: Self::Constraint,
2527 ) -> Result<(), ::fidl_next::ValidationError> {
2528 Ok(())
2529 }
2530 }
2531
2532 unsafe impl ::fidl_next::Wire for DirectoryRenameRequest<'static> {
2533 type Narrowed<'de> = DirectoryRenameRequest<'de>;
2534
2535 #[inline]
2536 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2537 ::fidl_next::munge! {
2538 let Self {
2539 src,
2540 dst_parent_token,
2541 dst,
2542
2543 } = &mut *out_;
2544 }
2545
2546 ::fidl_next::Wire::zero_padding(src);
2547
2548 ::fidl_next::Wire::zero_padding(dst_parent_token);
2549
2550 ::fidl_next::Wire::zero_padding(dst);
2551
2552 unsafe {
2553 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
2554 }
2555 }
2556 }
2557
2558 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryRenameRequest<'de>
2559 where
2560 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2561 ___D: ::fidl_next::Decoder<'de>,
2562 ___D: ::fidl_next::fuchsia::HandleDecoder,
2563 {
2564 fn decode(
2565 slot_: ::fidl_next::Slot<'_, Self>,
2566 decoder_: &mut ___D,
2567 _: (),
2568 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2569 if slot_.as_bytes()[20..24] != [0u8; 4] {
2570 return Err(::fidl_next::DecodeError::InvalidPadding);
2571 }
2572
2573 ::fidl_next::munge! {
2574 let Self {
2575 mut src,
2576 mut dst_parent_token,
2577 mut dst,
2578
2579 } = slot_;
2580 }
2581
2582 let _field = src.as_mut();
2583 ::fidl_next::Constrained::validate(_field, 255)?;
2584 ::fidl_next::Decode::decode(src.as_mut(), decoder_, 255)?;
2585
2586 let src = unsafe { src.deref_unchecked() };
2587
2588 if src.len() > 255 {
2589 return Err(::fidl_next::DecodeError::VectorTooLong {
2590 size: src.len() as u64,
2591 limit: 255,
2592 });
2593 }
2594
2595 let _field = dst_parent_token.as_mut();
2596
2597 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
2598
2599 let _field = dst.as_mut();
2600 ::fidl_next::Constrained::validate(_field, 255)?;
2601 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
2602
2603 let dst = unsafe { dst.deref_unchecked() };
2604
2605 if dst.len() > 255 {
2606 return Err(::fidl_next::DecodeError::VectorTooLong {
2607 size: dst.len() as u64,
2608 limit: 255,
2609 });
2610 }
2611
2612 Ok(())
2613 }
2614 }
2615
2616 impl<'de> ::fidl_next::IntoNatural for DirectoryRenameRequest<'de> {
2617 type Natural = crate::natural::DirectoryRenameRequest;
2618 }
2619
2620 #[derive(Debug)]
2622 #[repr(C)]
2623 pub struct DirectoryWatchRequest {
2624 pub mask: crate::wire::WatchMask,
2625
2626 pub options: ::fidl_next::wire::Uint32,
2627
2628 pub watcher:
2629 ::fidl_next::ServerEnd<crate::DirectoryWatcher, ::fidl_next::wire::fuchsia::Channel>,
2630 }
2631
2632 static_assertions::const_assert_eq!(std::mem::size_of::<DirectoryWatchRequest>(), 12);
2633 static_assertions::const_assert_eq!(std::mem::align_of::<DirectoryWatchRequest>(), 4);
2634
2635 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, mask), 0);
2636
2637 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, options), 4);
2638
2639 static_assertions::const_assert_eq!(std::mem::offset_of!(DirectoryWatchRequest, watcher), 8);
2640
2641 impl ::fidl_next::Constrained for DirectoryWatchRequest {
2642 type Constraint = ();
2643
2644 fn validate(
2645 _: ::fidl_next::Slot<'_, Self>,
2646 _: Self::Constraint,
2647 ) -> Result<(), ::fidl_next::ValidationError> {
2648 Ok(())
2649 }
2650 }
2651
2652 unsafe impl ::fidl_next::Wire for DirectoryWatchRequest {
2653 type Narrowed<'de> = DirectoryWatchRequest;
2654
2655 #[inline]
2656 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2657 ::fidl_next::munge! {
2658 let Self {
2659 mask,
2660 options,
2661 watcher,
2662
2663 } = &mut *out_;
2664 }
2665
2666 ::fidl_next::Wire::zero_padding(mask);
2667
2668 ::fidl_next::Wire::zero_padding(options);
2669
2670 ::fidl_next::Wire::zero_padding(watcher);
2671 }
2672 }
2673
2674 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryWatchRequest
2675 where
2676 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2677 ___D: ::fidl_next::fuchsia::HandleDecoder,
2678 {
2679 fn decode(
2680 slot_: ::fidl_next::Slot<'_, Self>,
2681 decoder_: &mut ___D,
2682 _: (),
2683 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2684 ::fidl_next::munge! {
2685 let Self {
2686 mut mask,
2687 mut options,
2688 mut watcher,
2689
2690 } = slot_;
2691 }
2692
2693 let _field = mask.as_mut();
2694
2695 ::fidl_next::Decode::decode(mask.as_mut(), decoder_, ())?;
2696
2697 let _field = options.as_mut();
2698
2699 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
2700
2701 let _field = watcher.as_mut();
2702
2703 ::fidl_next::Decode::decode(watcher.as_mut(), decoder_, ())?;
2704
2705 Ok(())
2706 }
2707 }
2708
2709 impl ::fidl_next::IntoNatural for DirectoryWatchRequest {
2710 type Natural = crate::natural::DirectoryWatchRequest;
2711 }
2712
2713 #[derive(Debug)]
2715 #[repr(C)]
2716 pub struct NodeListExtendedAttributesRequest {
2717 pub iterator: ::fidl_next::ServerEnd<
2718 crate::ExtendedAttributeIterator,
2719 ::fidl_next::wire::fuchsia::Channel,
2720 >,
2721 }
2722
2723 static_assertions::const_assert_eq!(
2724 std::mem::size_of::<NodeListExtendedAttributesRequest>(),
2725 4
2726 );
2727 static_assertions::const_assert_eq!(
2728 std::mem::align_of::<NodeListExtendedAttributesRequest>(),
2729 4
2730 );
2731
2732 static_assertions::const_assert_eq!(
2733 std::mem::offset_of!(NodeListExtendedAttributesRequest, iterator),
2734 0
2735 );
2736
2737 impl ::fidl_next::Constrained for NodeListExtendedAttributesRequest {
2738 type Constraint = ();
2739
2740 fn validate(
2741 _: ::fidl_next::Slot<'_, Self>,
2742 _: Self::Constraint,
2743 ) -> Result<(), ::fidl_next::ValidationError> {
2744 Ok(())
2745 }
2746 }
2747
2748 unsafe impl ::fidl_next::Wire for NodeListExtendedAttributesRequest {
2749 type Narrowed<'de> = NodeListExtendedAttributesRequest;
2750
2751 #[inline]
2752 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2753 ::fidl_next::munge! {
2754 let Self {
2755 iterator,
2756
2757 } = &mut *out_;
2758 }
2759
2760 ::fidl_next::Wire::zero_padding(iterator);
2761 }
2762 }
2763
2764 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeListExtendedAttributesRequest
2765 where
2766 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2767 ___D: ::fidl_next::fuchsia::HandleDecoder,
2768 {
2769 fn decode(
2770 slot_: ::fidl_next::Slot<'_, Self>,
2771 decoder_: &mut ___D,
2772 _: (),
2773 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2774 ::fidl_next::munge! {
2775 let Self {
2776 mut iterator,
2777
2778 } = slot_;
2779 }
2780
2781 let _field = iterator.as_mut();
2782
2783 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
2784
2785 Ok(())
2786 }
2787 }
2788
2789 impl ::fidl_next::IntoNatural for NodeListExtendedAttributesRequest {
2790 type Natural = crate::natural::NodeListExtendedAttributesRequest;
2791 }
2792
2793 #[repr(transparent)]
2795 pub struct ExtendedAttributeValue<'de> {
2796 pub(crate) raw: ::fidl_next::wire::Union,
2797 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
2798 }
2799
2800 impl<'de> Drop for ExtendedAttributeValue<'de> {
2801 fn drop(&mut self) {
2802 match self.raw.ordinal() {
2803 1 => {
2804 let _ = unsafe {
2805 self.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2806 };
2807 }
2808
2809 2 => {
2810 let _ = unsafe {
2811 self.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
2812 };
2813 }
2814
2815 _ => (),
2816 }
2817 }
2818 }
2819
2820 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
2821 type Constraint = ();
2822
2823 fn validate(
2824 _: ::fidl_next::Slot<'_, Self>,
2825 _: Self::Constraint,
2826 ) -> Result<(), ::fidl_next::ValidationError> {
2827 Ok(())
2828 }
2829 }
2830
2831 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
2832 type Narrowed<'de> = ExtendedAttributeValue<'de>;
2833
2834 #[inline]
2835 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
2836 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
2837 ::fidl_next::wire::Union::zero_padding(raw);
2838 }
2839 }
2840
2841 pub mod extended_attribute_value {
2842 pub enum Ref<'de> {
2843 Bytes(&'de ::fidl_next::wire::Vector<'de, u8>),
2844
2845 Buffer(&'de ::fidl_next::wire::fuchsia::Vmo),
2846
2847 UnknownOrdinal_(u64),
2848 }
2849
2850 pub enum Value<'de> {
2851 Bytes(::fidl_next::wire::Vector<'de, u8>),
2852
2853 Buffer(::fidl_next::wire::fuchsia::Vmo),
2854
2855 UnknownOrdinal_(u64),
2856 }
2857 }
2858
2859 impl<'de> ExtendedAttributeValue<'de> {
2860 pub fn as_ref(&self) -> crate::wire::extended_attribute_value::Ref<'_> {
2861 match self.raw.ordinal() {
2862 1 => crate::wire::extended_attribute_value::Ref::Bytes(unsafe {
2863 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>()
2864 }),
2865
2866 2 => crate::wire::extended_attribute_value::Ref::Buffer(unsafe {
2867 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
2868 }),
2869
2870 unknown => crate::wire::extended_attribute_value::Ref::UnknownOrdinal_(unknown),
2871 }
2872 }
2873
2874 pub fn into_inner(self) -> crate::wire::extended_attribute_value::Value<'de> {
2875 let this = ::core::mem::ManuallyDrop::new(self);
2876
2877 match this.raw.ordinal() {
2878 1 => crate::wire::extended_attribute_value::Value::Bytes(unsafe {
2879 this.raw.get().read_unchecked::<::fidl_next::wire::Vector<'de, u8>>()
2880 }),
2881
2882 2 => crate::wire::extended_attribute_value::Value::Buffer(unsafe {
2883 this.raw.get().read_unchecked::<::fidl_next::wire::fuchsia::Vmo>()
2884 }),
2885
2886 unknown => crate::wire::extended_attribute_value::Value::UnknownOrdinal_(unknown),
2887 }
2888 }
2889 }
2890
2891 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
2892 where
2893 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2894 ___D: ::fidl_next::Decoder<'de>,
2895 ___D: ::fidl_next::fuchsia::HandleDecoder,
2896 {
2897 fn decode(
2898 mut slot: ::fidl_next::Slot<'_, Self>,
2899 decoder: &mut ___D,
2900 _: (),
2901 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2902 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
2903 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
2904 1 => {
2905 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
2906 raw,
2907 decoder,
2908 (32768, ()),
2909 )?
2910 }
2911
2912 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::fuchsia::Vmo>(
2913 raw,
2914 decoder,
2915 (),
2916 )?,
2917
2918 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
2919 }
2920
2921 Ok(())
2922 }
2923 }
2924
2925 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
2926 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2927 match self.raw.ordinal() {
2928 1 => unsafe {
2929 self.raw.get().deref_unchecked::<::fidl_next::wire::Vector<'_, u8>>().fmt(f)
2930 },
2931 2 => unsafe {
2932 self.raw.get().deref_unchecked::<::fidl_next::wire::fuchsia::Vmo>().fmt(f)
2933 },
2934 _ => unsafe { ::core::hint::unreachable_unchecked() },
2935 }
2936 }
2937 }
2938
2939 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
2940 type Natural = crate::natural::ExtendedAttributeValue;
2941 }
2942
2943 #[derive(Debug)]
2945 #[repr(C)]
2946 pub struct NodeSetExtendedAttributeRequest<'de> {
2947 pub name: ::fidl_next::wire::Vector<'de, u8>,
2948
2949 pub value: crate::wire::ExtendedAttributeValue<'de>,
2950
2951 pub mode: crate::wire::SetExtendedAttributeMode,
2952 }
2953
2954 static_assertions::const_assert_eq!(
2955 std::mem::size_of::<NodeSetExtendedAttributeRequest<'_>>(),
2956 40
2957 );
2958 static_assertions::const_assert_eq!(
2959 std::mem::align_of::<NodeSetExtendedAttributeRequest<'_>>(),
2960 8
2961 );
2962
2963 static_assertions::const_assert_eq!(
2964 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, name),
2965 0
2966 );
2967
2968 static_assertions::const_assert_eq!(
2969 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, value),
2970 16
2971 );
2972
2973 static_assertions::const_assert_eq!(
2974 std::mem::offset_of!(NodeSetExtendedAttributeRequest<'_>, mode),
2975 32
2976 );
2977
2978 impl ::fidl_next::Constrained for NodeSetExtendedAttributeRequest<'_> {
2979 type Constraint = ();
2980
2981 fn validate(
2982 _: ::fidl_next::Slot<'_, Self>,
2983 _: Self::Constraint,
2984 ) -> Result<(), ::fidl_next::ValidationError> {
2985 Ok(())
2986 }
2987 }
2988
2989 unsafe impl ::fidl_next::Wire for NodeSetExtendedAttributeRequest<'static> {
2990 type Narrowed<'de> = NodeSetExtendedAttributeRequest<'de>;
2991
2992 #[inline]
2993 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2994 ::fidl_next::munge! {
2995 let Self {
2996 name,
2997 value,
2998 mode,
2999
3000 } = &mut *out_;
3001 }
3002
3003 ::fidl_next::Wire::zero_padding(name);
3004
3005 ::fidl_next::Wire::zero_padding(value);
3006
3007 ::fidl_next::Wire::zero_padding(mode);
3008
3009 unsafe {
3010 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
3011 }
3012 }
3013 }
3014
3015 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeSetExtendedAttributeRequest<'de>
3016 where
3017 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3018 ___D: ::fidl_next::Decoder<'de>,
3019 ___D: ::fidl_next::fuchsia::HandleDecoder,
3020 {
3021 fn decode(
3022 slot_: ::fidl_next::Slot<'_, Self>,
3023 decoder_: &mut ___D,
3024 _: (),
3025 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3026 if slot_.as_bytes()[36..40] != [0u8; 4] {
3027 return Err(::fidl_next::DecodeError::InvalidPadding);
3028 }
3029
3030 ::fidl_next::munge! {
3031 let Self {
3032 mut name,
3033 mut value,
3034 mut mode,
3035
3036 } = slot_;
3037 }
3038
3039 let _field = name.as_mut();
3040 ::fidl_next::Constrained::validate(_field, (255, ()))?;
3041 ::fidl_next::Decode::decode(name.as_mut(), decoder_, (255, ()))?;
3042
3043 let name = unsafe { name.deref_unchecked() };
3044
3045 if name.len() > 255 {
3046 return Err(::fidl_next::DecodeError::VectorTooLong {
3047 size: name.len() as u64,
3048 limit: 255,
3049 });
3050 }
3051
3052 let _field = value.as_mut();
3053
3054 ::fidl_next::Decode::decode(value.as_mut(), decoder_, ())?;
3055
3056 let _field = mode.as_mut();
3057
3058 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3059
3060 Ok(())
3061 }
3062 }
3063
3064 impl<'de> ::fidl_next::IntoNatural for NodeSetExtendedAttributeRequest<'de> {
3065 type Natural = crate::natural::NodeSetExtendedAttributeRequest;
3066 }
3067
3068 #[derive(Debug)]
3070 #[repr(C)]
3071 pub struct NodeGetTokenResponse {
3072 pub token: ::fidl_next::wire::fuchsia::Event,
3073 }
3074
3075 static_assertions::const_assert_eq!(std::mem::size_of::<NodeGetTokenResponse>(), 4);
3076 static_assertions::const_assert_eq!(std::mem::align_of::<NodeGetTokenResponse>(), 4);
3077
3078 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeGetTokenResponse, token), 0);
3079
3080 impl ::fidl_next::Constrained for NodeGetTokenResponse {
3081 type Constraint = ();
3082
3083 fn validate(
3084 _: ::fidl_next::Slot<'_, Self>,
3085 _: Self::Constraint,
3086 ) -> Result<(), ::fidl_next::ValidationError> {
3087 Ok(())
3088 }
3089 }
3090
3091 unsafe impl ::fidl_next::Wire for NodeGetTokenResponse {
3092 type Narrowed<'de> = NodeGetTokenResponse;
3093
3094 #[inline]
3095 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3096 ::fidl_next::munge! {
3097 let Self {
3098 token,
3099
3100 } = &mut *out_;
3101 }
3102
3103 ::fidl_next::Wire::zero_padding(token);
3104 }
3105 }
3106
3107 unsafe impl<___D> ::fidl_next::Decode<___D> for NodeGetTokenResponse
3108 where
3109 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3110 ___D: ::fidl_next::fuchsia::HandleDecoder,
3111 {
3112 fn decode(
3113 slot_: ::fidl_next::Slot<'_, Self>,
3114 decoder_: &mut ___D,
3115 _: (),
3116 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3117 ::fidl_next::munge! {
3118 let Self {
3119 mut token,
3120
3121 } = slot_;
3122 }
3123
3124 let _field = token.as_mut();
3125
3126 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3127
3128 Ok(())
3129 }
3130 }
3131
3132 impl ::fidl_next::IntoNatural for NodeGetTokenResponse {
3133 type Natural = crate::natural::NodeGetTokenResponse;
3134 }
3135
3136 #[derive(Debug)]
3138 #[repr(C)]
3139 pub struct DirectoryDeprecatedGetTokenResponse {
3140 pub s: ::fidl_next::wire::fuchsia::StatusResult,
3141
3142 pub token: ::fidl_next::wire::fuchsia::OptionalNullableHandle,
3143 }
3144
3145 static_assertions::const_assert_eq!(
3146 std::mem::size_of::<DirectoryDeprecatedGetTokenResponse>(),
3147 8
3148 );
3149 static_assertions::const_assert_eq!(
3150 std::mem::align_of::<DirectoryDeprecatedGetTokenResponse>(),
3151 4
3152 );
3153
3154 static_assertions::const_assert_eq!(
3155 std::mem::offset_of!(DirectoryDeprecatedGetTokenResponse, s),
3156 0
3157 );
3158
3159 static_assertions::const_assert_eq!(
3160 std::mem::offset_of!(DirectoryDeprecatedGetTokenResponse, token),
3161 4
3162 );
3163
3164 impl ::fidl_next::Constrained for DirectoryDeprecatedGetTokenResponse {
3165 type Constraint = ();
3166
3167 fn validate(
3168 _: ::fidl_next::Slot<'_, Self>,
3169 _: Self::Constraint,
3170 ) -> Result<(), ::fidl_next::ValidationError> {
3171 Ok(())
3172 }
3173 }
3174
3175 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedGetTokenResponse {
3176 type Narrowed<'de> = DirectoryDeprecatedGetTokenResponse;
3177
3178 #[inline]
3179 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3180 ::fidl_next::munge! {
3181 let Self {
3182 s,
3183 token,
3184
3185 } = &mut *out_;
3186 }
3187
3188 ::fidl_next::Wire::zero_padding(s);
3189
3190 ::fidl_next::Wire::zero_padding(token);
3191 }
3192 }
3193
3194 unsafe impl<___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedGetTokenResponse
3195 where
3196 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3197 ___D: ::fidl_next::fuchsia::HandleDecoder,
3198 {
3199 fn decode(
3200 slot_: ::fidl_next::Slot<'_, Self>,
3201 decoder_: &mut ___D,
3202 _: (),
3203 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3204 ::fidl_next::munge! {
3205 let Self {
3206 mut s,
3207 mut token,
3208
3209 } = slot_;
3210 }
3211
3212 let _field = s.as_mut();
3213
3214 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
3215
3216 let _field = token.as_mut();
3217
3218 ::fidl_next::Decode::decode(token.as_mut(), decoder_, ())?;
3219
3220 Ok(())
3221 }
3222 }
3223
3224 impl ::fidl_next::IntoNatural for DirectoryDeprecatedGetTokenResponse {
3225 type Natural = crate::natural::DirectoryDeprecatedGetTokenResponse;
3226 }
3227
3228 #[repr(C)]
3230 pub struct FileInfo<'de> {
3231 pub(crate) table: ::fidl_next::wire::Table<'de>,
3232 }
3233
3234 impl<'de> Drop for FileInfo<'de> {
3235 fn drop(&mut self) {
3236 let _ = self.table.get(1).map(|envelope| unsafe { envelope.read_unchecked::<bool>() });
3237
3238 let _ = self.table.get(2).map(|envelope| unsafe {
3239 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Event>()
3240 });
3241
3242 let _ = self.table.get(3).map(|envelope| unsafe {
3243 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Stream>()
3244 });
3245
3246 let _ = self.table.get(4).map(|envelope| unsafe {
3247 envelope.read_unchecked::<crate::wire::NodeAttributes2<'de>>()
3248 });
3249 }
3250 }
3251
3252 impl ::fidl_next::Constrained for FileInfo<'_> {
3253 type Constraint = ();
3254
3255 fn validate(
3256 _: ::fidl_next::Slot<'_, Self>,
3257 _: Self::Constraint,
3258 ) -> Result<(), ::fidl_next::ValidationError> {
3259 Ok(())
3260 }
3261 }
3262
3263 unsafe impl ::fidl_next::Wire for FileInfo<'static> {
3264 type Narrowed<'de> = FileInfo<'de>;
3265
3266 #[inline]
3267 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3268 ::fidl_next::munge!(let Self { table } = out);
3269 ::fidl_next::wire::Table::zero_padding(table);
3270 }
3271 }
3272
3273 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileInfo<'de>
3274 where
3275 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3276 ___D: ::fidl_next::fuchsia::HandleDecoder,
3277 {
3278 fn decode(
3279 slot: ::fidl_next::Slot<'_, Self>,
3280 decoder: &mut ___D,
3281 _: (),
3282 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3283 ::fidl_next::munge!(let Self { table } = slot);
3284
3285 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3286 match ordinal {
3287 0 => unsafe { ::core::hint::unreachable_unchecked() },
3288
3289 1 => {
3290 ::fidl_next::wire::Envelope::decode_as::<___D, bool>(
3291 slot.as_mut(),
3292 decoder,
3293 (),
3294 )?;
3295
3296 Ok(())
3297 }
3298
3299 2 => {
3300 ::fidl_next::wire::Envelope::decode_as::<
3301 ___D,
3302 ::fidl_next::wire::fuchsia::Event,
3303 >(slot.as_mut(), decoder, ())?;
3304
3305 Ok(())
3306 }
3307
3308 3 => {
3309 ::fidl_next::wire::Envelope::decode_as::<
3310 ___D,
3311 ::fidl_next::wire::fuchsia::Stream,
3312 >(slot.as_mut(), decoder, ())?;
3313
3314 Ok(())
3315 }
3316
3317 4 => {
3318 ::fidl_next::wire::Envelope::decode_as::<
3319 ___D,
3320 crate::wire::NodeAttributes2<'de>,
3321 >(slot.as_mut(), decoder, ())?;
3322
3323 Ok(())
3324 }
3325
3326 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3327 }
3328 })
3329 }
3330 }
3331
3332 impl<'de> FileInfo<'de> {
3333 pub fn is_append(&self) -> ::core::option::Option<&bool> {
3334 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3335 }
3336
3337 pub fn take_is_append(&mut self) -> ::core::option::Option<bool> {
3338 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3339 }
3340
3341 pub fn observer(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Event> {
3342 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3343 }
3344
3345 pub fn take_observer(
3346 &mut self,
3347 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Event> {
3348 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3349 }
3350
3351 pub fn stream(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Stream> {
3352 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3353 }
3354
3355 pub fn take_stream(
3356 &mut self,
3357 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Stream> {
3358 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3359 }
3360
3361 pub fn attributes(&self) -> ::core::option::Option<&crate::wire::NodeAttributes2<'de>> {
3362 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3363 }
3364
3365 pub fn take_attributes(
3366 &mut self,
3367 ) -> ::core::option::Option<crate::wire::NodeAttributes2<'de>> {
3368 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3369 }
3370 }
3371
3372 impl<'de> ::core::fmt::Debug for FileInfo<'de> {
3373 fn fmt(
3374 &self,
3375 f: &mut ::core::fmt::Formatter<'_>,
3376 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3377 f.debug_struct("FileInfo")
3378 .field("is_append", &self.is_append())
3379 .field("observer", &self.observer())
3380 .field("stream", &self.stream())
3381 .field("attributes", &self.attributes())
3382 .finish()
3383 }
3384 }
3385
3386 impl<'de> ::fidl_next::IntoNatural for FileInfo<'de> {
3387 type Natural = crate::natural::FileInfo;
3388 }
3389
3390 #[repr(transparent)]
3392 pub struct Representation<'de> {
3393 pub(crate) raw: ::fidl_next::wire::Union,
3394 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
3395 }
3396
3397 impl<'de> Drop for Representation<'de> {
3398 fn drop(&mut self) {
3399 match self.raw.ordinal() {
3400 1 => {
3401 let _ =
3402 unsafe { self.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>() };
3403 }
3404
3405 2 => {
3406 let _ = unsafe {
3407 self.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3408 };
3409 }
3410
3411 3 => {
3412 let _ =
3413 unsafe { self.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>() };
3414 }
3415
3416 4 => {
3417 let _ =
3418 unsafe { self.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>() };
3419 }
3420
3421 _ => (),
3422 }
3423 }
3424 }
3425
3426 impl ::fidl_next::Constrained for Representation<'_> {
3427 type Constraint = ();
3428
3429 fn validate(
3430 _: ::fidl_next::Slot<'_, Self>,
3431 _: Self::Constraint,
3432 ) -> Result<(), ::fidl_next::ValidationError> {
3433 Ok(())
3434 }
3435 }
3436
3437 unsafe impl ::fidl_next::Wire for Representation<'static> {
3438 type Narrowed<'de> = Representation<'de>;
3439
3440 #[inline]
3441 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3442 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
3443 ::fidl_next::wire::Union::zero_padding(raw);
3444 }
3445 }
3446
3447 pub mod representation {
3448 pub enum Ref<'de> {
3449 Node(&'de crate::wire::NodeInfo<'de>),
3450
3451 Directory(&'de crate::wire::DirectoryInfo<'de>),
3452
3453 File(&'de crate::wire::FileInfo<'de>),
3454
3455 Symlink(&'de crate::wire::SymlinkInfo<'de>),
3456
3457 UnknownOrdinal_(u64),
3458 }
3459
3460 pub enum Value<'de> {
3461 Node(crate::wire::NodeInfo<'de>),
3462
3463 Directory(crate::wire::DirectoryInfo<'de>),
3464
3465 File(crate::wire::FileInfo<'de>),
3466
3467 Symlink(crate::wire::SymlinkInfo<'de>),
3468
3469 UnknownOrdinal_(u64),
3470 }
3471 }
3472
3473 impl<'de> Representation<'de> {
3474 pub fn as_ref(&self) -> crate::wire::representation::Ref<'_> {
3475 match self.raw.ordinal() {
3476 1 => crate::wire::representation::Ref::Node(unsafe {
3477 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>()
3478 }),
3479
3480 2 => crate::wire::representation::Ref::Directory(unsafe {
3481 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>()
3482 }),
3483
3484 3 => crate::wire::representation::Ref::File(unsafe {
3485 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>()
3486 }),
3487
3488 4 => crate::wire::representation::Ref::Symlink(unsafe {
3489 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>()
3490 }),
3491
3492 unknown => crate::wire::representation::Ref::UnknownOrdinal_(unknown),
3493 }
3494 }
3495
3496 pub fn into_inner(self) -> crate::wire::representation::Value<'de> {
3497 let this = ::core::mem::ManuallyDrop::new(self);
3498
3499 match this.raw.ordinal() {
3500 1 => crate::wire::representation::Value::Node(unsafe {
3501 this.raw.get().read_unchecked::<crate::wire::NodeInfo<'de>>()
3502 }),
3503
3504 2 => crate::wire::representation::Value::Directory(unsafe {
3505 this.raw.get().read_unchecked::<crate::wire::DirectoryInfo<'de>>()
3506 }),
3507
3508 3 => crate::wire::representation::Value::File(unsafe {
3509 this.raw.get().read_unchecked::<crate::wire::FileInfo<'de>>()
3510 }),
3511
3512 4 => crate::wire::representation::Value::Symlink(unsafe {
3513 this.raw.get().read_unchecked::<crate::wire::SymlinkInfo<'de>>()
3514 }),
3515
3516 unknown => crate::wire::representation::Value::UnknownOrdinal_(unknown),
3517 }
3518 }
3519 }
3520
3521 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
3522 where
3523 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3524 ___D: ::fidl_next::Decoder<'de>,
3525 ___D: ::fidl_next::fuchsia::HandleDecoder,
3526 {
3527 fn decode(
3528 mut slot: ::fidl_next::Slot<'_, Self>,
3529 decoder: &mut ___D,
3530 _: (),
3531 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3532 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
3533 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
3534 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
3535 raw,
3536 decoder,
3537 (),
3538 )?,
3539
3540 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
3541 raw,
3542 decoder,
3543 (),
3544 )?,
3545
3546 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
3547 raw,
3548 decoder,
3549 (),
3550 )?,
3551
3552 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
3553 raw,
3554 decoder,
3555 (),
3556 )?,
3557
3558 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
3559 }
3560
3561 Ok(())
3562 }
3563 }
3564
3565 impl<'de> ::core::fmt::Debug for Representation<'de> {
3566 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3567 match self.raw.ordinal() {
3568 1 => unsafe {
3569 self.raw.get().deref_unchecked::<crate::wire::NodeInfo<'_>>().fmt(f)
3570 },
3571 2 => unsafe {
3572 self.raw.get().deref_unchecked::<crate::wire::DirectoryInfo<'_>>().fmt(f)
3573 },
3574 3 => unsafe {
3575 self.raw.get().deref_unchecked::<crate::wire::FileInfo<'_>>().fmt(f)
3576 },
3577 4 => unsafe {
3578 self.raw.get().deref_unchecked::<crate::wire::SymlinkInfo<'_>>().fmt(f)
3579 },
3580 _ => unsafe { ::core::hint::unreachable_unchecked() },
3581 }
3582 }
3583 }
3584
3585 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
3586 type Natural = crate::natural::Representation;
3587 }
3588
3589 #[derive(Debug)]
3591 #[repr(C)]
3592 pub struct OpenableOpenRequest<'de> {
3593 pub path: ::fidl_next::wire::String<'de>,
3594
3595 pub flags: crate::wire::Flags,
3596
3597 pub options: crate::wire::Options<'de>,
3598
3599 pub object: ::fidl_next::wire::fuchsia::Channel,
3600 }
3601
3602 static_assertions::const_assert_eq!(std::mem::size_of::<OpenableOpenRequest<'_>>(), 48);
3603 static_assertions::const_assert_eq!(std::mem::align_of::<OpenableOpenRequest<'_>>(), 8);
3604
3605 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, path), 0);
3606
3607 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, flags), 16);
3608
3609 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, options), 24);
3610
3611 static_assertions::const_assert_eq!(std::mem::offset_of!(OpenableOpenRequest<'_>, object), 40);
3612
3613 impl ::fidl_next::Constrained for OpenableOpenRequest<'_> {
3614 type Constraint = ();
3615
3616 fn validate(
3617 _: ::fidl_next::Slot<'_, Self>,
3618 _: Self::Constraint,
3619 ) -> Result<(), ::fidl_next::ValidationError> {
3620 Ok(())
3621 }
3622 }
3623
3624 unsafe impl ::fidl_next::Wire for OpenableOpenRequest<'static> {
3625 type Narrowed<'de> = OpenableOpenRequest<'de>;
3626
3627 #[inline]
3628 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3629 ::fidl_next::munge! {
3630 let Self {
3631 path,
3632 flags,
3633 options,
3634 object,
3635
3636 } = &mut *out_;
3637 }
3638
3639 ::fidl_next::Wire::zero_padding(path);
3640
3641 ::fidl_next::Wire::zero_padding(flags);
3642
3643 ::fidl_next::Wire::zero_padding(options);
3644
3645 ::fidl_next::Wire::zero_padding(object);
3646
3647 unsafe {
3648 out_.as_mut_ptr().cast::<u8>().add(44).write_bytes(0, 4);
3649 }
3650 }
3651 }
3652
3653 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for OpenableOpenRequest<'de>
3654 where
3655 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3656 ___D: ::fidl_next::Decoder<'de>,
3657 ___D: ::fidl_next::fuchsia::HandleDecoder,
3658 {
3659 fn decode(
3660 slot_: ::fidl_next::Slot<'_, Self>,
3661 decoder_: &mut ___D,
3662 _: (),
3663 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3664 if slot_.as_bytes()[44..48] != [0u8; 4] {
3665 return Err(::fidl_next::DecodeError::InvalidPadding);
3666 }
3667
3668 ::fidl_next::munge! {
3669 let Self {
3670 mut path,
3671 mut flags,
3672 mut options,
3673 mut object,
3674
3675 } = slot_;
3676 }
3677
3678 let _field = path.as_mut();
3679 ::fidl_next::Constrained::validate(_field, 4095)?;
3680 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3681
3682 let path = unsafe { path.deref_unchecked() };
3683
3684 if path.len() > 4095 {
3685 return Err(::fidl_next::DecodeError::VectorTooLong {
3686 size: path.len() as u64,
3687 limit: 4095,
3688 });
3689 }
3690
3691 let _field = flags.as_mut();
3692
3693 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3694
3695 let _field = options.as_mut();
3696
3697 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
3698
3699 let _field = object.as_mut();
3700
3701 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3702
3703 Ok(())
3704 }
3705 }
3706
3707 impl<'de> ::fidl_next::IntoNatural for OpenableOpenRequest<'de> {
3708 type Natural = crate::natural::OpenableOpenRequest;
3709 }
3710
3711 #[derive(Debug)]
3713 #[repr(C)]
3714 pub struct NodeOnOpenRequest<'de> {
3715 pub s: ::fidl_next::wire::fuchsia::StatusResult,
3716
3717 pub info: crate::wire_optional::NodeInfoDeprecated<'de>,
3718 }
3719
3720 static_assertions::const_assert_eq!(std::mem::size_of::<NodeOnOpenRequest<'_>>(), 24);
3721 static_assertions::const_assert_eq!(std::mem::align_of::<NodeOnOpenRequest<'_>>(), 8);
3722
3723 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, s), 0);
3724
3725 static_assertions::const_assert_eq!(std::mem::offset_of!(NodeOnOpenRequest<'_>, info), 8);
3726
3727 impl ::fidl_next::Constrained for NodeOnOpenRequest<'_> {
3728 type Constraint = ();
3729
3730 fn validate(
3731 _: ::fidl_next::Slot<'_, Self>,
3732 _: Self::Constraint,
3733 ) -> Result<(), ::fidl_next::ValidationError> {
3734 Ok(())
3735 }
3736 }
3737
3738 unsafe impl ::fidl_next::Wire for NodeOnOpenRequest<'static> {
3739 type Narrowed<'de> = NodeOnOpenRequest<'de>;
3740
3741 #[inline]
3742 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3743 ::fidl_next::munge! {
3744 let Self {
3745 s,
3746 info,
3747
3748 } = &mut *out_;
3749 }
3750
3751 ::fidl_next::Wire::zero_padding(s);
3752
3753 ::fidl_next::Wire::zero_padding(info);
3754
3755 unsafe {
3756 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
3757 }
3758 }
3759 }
3760
3761 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeOnOpenRequest<'de>
3762 where
3763 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3764 ___D: ::fidl_next::Decoder<'de>,
3765 ___D: ::fidl_next::fuchsia::HandleDecoder,
3766 {
3767 fn decode(
3768 slot_: ::fidl_next::Slot<'_, Self>,
3769 decoder_: &mut ___D,
3770 _: (),
3771 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3772 if slot_.as_bytes()[4..8] != [0u8; 4] {
3773 return Err(::fidl_next::DecodeError::InvalidPadding);
3774 }
3775
3776 ::fidl_next::munge! {
3777 let Self {
3778 mut s,
3779 mut info,
3780
3781 } = slot_;
3782 }
3783
3784 let _field = s.as_mut();
3785
3786 ::fidl_next::Decode::decode(s.as_mut(), decoder_, ())?;
3787
3788 let _field = info.as_mut();
3789
3790 ::fidl_next::Decode::decode(info.as_mut(), decoder_, ())?;
3791
3792 Ok(())
3793 }
3794 }
3795
3796 impl<'de> ::fidl_next::IntoNatural for NodeOnOpenRequest<'de> {
3797 type Natural = crate::natural::NodeOnOpenRequest;
3798 }
3799
3800 #[derive(Debug)]
3802 #[repr(C)]
3803 pub struct DirectoryDeprecatedOpenRequest<'de> {
3804 pub flags: crate::wire::OpenFlags,
3805
3806 pub mode: crate::wire::ModeType,
3807
3808 pub path: ::fidl_next::wire::String<'de>,
3809
3810 pub object: ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
3811 }
3812
3813 static_assertions::const_assert_eq!(
3814 std::mem::size_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3815 32
3816 );
3817 static_assertions::const_assert_eq!(
3818 std::mem::align_of::<DirectoryDeprecatedOpenRequest<'_>>(),
3819 8
3820 );
3821
3822 static_assertions::const_assert_eq!(
3823 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, flags),
3824 0
3825 );
3826
3827 static_assertions::const_assert_eq!(
3828 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, mode),
3829 4
3830 );
3831
3832 static_assertions::const_assert_eq!(
3833 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, path),
3834 8
3835 );
3836
3837 static_assertions::const_assert_eq!(
3838 std::mem::offset_of!(DirectoryDeprecatedOpenRequest<'_>, object),
3839 24
3840 );
3841
3842 impl ::fidl_next::Constrained for DirectoryDeprecatedOpenRequest<'_> {
3843 type Constraint = ();
3844
3845 fn validate(
3846 _: ::fidl_next::Slot<'_, Self>,
3847 _: Self::Constraint,
3848 ) -> Result<(), ::fidl_next::ValidationError> {
3849 Ok(())
3850 }
3851 }
3852
3853 unsafe impl ::fidl_next::Wire for DirectoryDeprecatedOpenRequest<'static> {
3854 type Narrowed<'de> = DirectoryDeprecatedOpenRequest<'de>;
3855
3856 #[inline]
3857 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3858 ::fidl_next::munge! {
3859 let Self {
3860 flags,
3861 mode,
3862 path,
3863 object,
3864
3865 } = &mut *out_;
3866 }
3867
3868 ::fidl_next::Wire::zero_padding(flags);
3869
3870 ::fidl_next::Wire::zero_padding(mode);
3871
3872 ::fidl_next::Wire::zero_padding(path);
3873
3874 ::fidl_next::Wire::zero_padding(object);
3875
3876 unsafe {
3877 out_.as_mut_ptr().cast::<u8>().add(28).write_bytes(0, 4);
3878 }
3879 }
3880 }
3881
3882 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryDeprecatedOpenRequest<'de>
3883 where
3884 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3885 ___D: ::fidl_next::Decoder<'de>,
3886 ___D: ::fidl_next::fuchsia::HandleDecoder,
3887 {
3888 fn decode(
3889 slot_: ::fidl_next::Slot<'_, Self>,
3890 decoder_: &mut ___D,
3891 _: (),
3892 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3893 if slot_.as_bytes()[28..32] != [0u8; 4] {
3894 return Err(::fidl_next::DecodeError::InvalidPadding);
3895 }
3896
3897 ::fidl_next::munge! {
3898 let Self {
3899 mut flags,
3900 mut mode,
3901 mut path,
3902 mut object,
3903
3904 } = slot_;
3905 }
3906
3907 let _field = flags.as_mut();
3908
3909 ::fidl_next::Decode::decode(flags.as_mut(), decoder_, ())?;
3910
3911 let _field = mode.as_mut();
3912
3913 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
3914
3915 let _field = path.as_mut();
3916 ::fidl_next::Constrained::validate(_field, 4095)?;
3917 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
3918
3919 let path = unsafe { path.deref_unchecked() };
3920
3921 if path.len() > 4095 {
3922 return Err(::fidl_next::DecodeError::VectorTooLong {
3923 size: path.len() as u64,
3924 limit: 4095,
3925 });
3926 }
3927
3928 let _field = object.as_mut();
3929
3930 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
3931
3932 Ok(())
3933 }
3934 }
3935
3936 impl<'de> ::fidl_next::IntoNatural for DirectoryDeprecatedOpenRequest<'de> {
3937 type Natural = crate::natural::DirectoryDeprecatedOpenRequest;
3938 }
3939
3940 #[derive(Debug)]
3942 #[repr(C)]
3943 pub struct DirectoryCreateSymlinkRequest<'de> {
3944 pub name: ::fidl_next::wire::String<'de>,
3945
3946 pub target: ::fidl_next::wire::Vector<'de, u8>,
3947
3948 pub connection:
3949 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::wire::fuchsia::OptionalChannel>,
3950 }
3951
3952 static_assertions::const_assert_eq!(
3953 std::mem::size_of::<DirectoryCreateSymlinkRequest<'_>>(),
3954 40
3955 );
3956 static_assertions::const_assert_eq!(
3957 std::mem::align_of::<DirectoryCreateSymlinkRequest<'_>>(),
3958 8
3959 );
3960
3961 static_assertions::const_assert_eq!(
3962 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, name),
3963 0
3964 );
3965
3966 static_assertions::const_assert_eq!(
3967 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, target),
3968 16
3969 );
3970
3971 static_assertions::const_assert_eq!(
3972 std::mem::offset_of!(DirectoryCreateSymlinkRequest<'_>, connection),
3973 32
3974 );
3975
3976 impl ::fidl_next::Constrained for DirectoryCreateSymlinkRequest<'_> {
3977 type Constraint = ();
3978
3979 fn validate(
3980 _: ::fidl_next::Slot<'_, Self>,
3981 _: Self::Constraint,
3982 ) -> Result<(), ::fidl_next::ValidationError> {
3983 Ok(())
3984 }
3985 }
3986
3987 unsafe impl ::fidl_next::Wire for DirectoryCreateSymlinkRequest<'static> {
3988 type Narrowed<'de> = DirectoryCreateSymlinkRequest<'de>;
3989
3990 #[inline]
3991 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3992 ::fidl_next::munge! {
3993 let Self {
3994 name,
3995 target,
3996 connection,
3997
3998 } = &mut *out_;
3999 }
4000
4001 ::fidl_next::Wire::zero_padding(name);
4002
4003 ::fidl_next::Wire::zero_padding(target);
4004
4005 ::fidl_next::Wire::zero_padding(connection);
4006
4007 unsafe {
4008 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
4009 }
4010 }
4011 }
4012
4013 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DirectoryCreateSymlinkRequest<'de>
4014 where
4015 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4016 ___D: ::fidl_next::Decoder<'de>,
4017 ___D: ::fidl_next::fuchsia::HandleDecoder,
4018 {
4019 fn decode(
4020 slot_: ::fidl_next::Slot<'_, Self>,
4021 decoder_: &mut ___D,
4022 _: (),
4023 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4024 if slot_.as_bytes()[36..40] != [0u8; 4] {
4025 return Err(::fidl_next::DecodeError::InvalidPadding);
4026 }
4027
4028 ::fidl_next::munge! {
4029 let Self {
4030 mut name,
4031 mut target,
4032 mut connection,
4033
4034 } = slot_;
4035 }
4036
4037 let _field = name.as_mut();
4038 ::fidl_next::Constrained::validate(_field, 255)?;
4039 ::fidl_next::Decode::decode(name.as_mut(), decoder_, 255)?;
4040
4041 let name = unsafe { name.deref_unchecked() };
4042
4043 if name.len() > 255 {
4044 return Err(::fidl_next::DecodeError::VectorTooLong {
4045 size: name.len() as u64,
4046 limit: 255,
4047 });
4048 }
4049
4050 let _field = target.as_mut();
4051 ::fidl_next::Constrained::validate(_field, (4095, ()))?;
4052 ::fidl_next::Decode::decode(target.as_mut(), decoder_, (4095, ()))?;
4053
4054 let target = unsafe { target.deref_unchecked() };
4055
4056 if target.len() > 4095 {
4057 return Err(::fidl_next::DecodeError::VectorTooLong {
4058 size: target.len() as u64,
4059 limit: 4095,
4060 });
4061 }
4062
4063 let _field = connection.as_mut();
4064
4065 ::fidl_next::Decode::decode(connection.as_mut(), decoder_, ())?;
4066
4067 Ok(())
4068 }
4069 }
4070
4071 impl<'de> ::fidl_next::IntoNatural for DirectoryCreateSymlinkRequest<'de> {
4072 type Natural = crate::natural::DirectoryCreateSymlinkRequest;
4073 }
4074
4075 #[derive(Debug)]
4077 #[repr(C)]
4078 pub struct FileGetBackingMemoryResponse {
4079 pub vmo: ::fidl_next::wire::fuchsia::Vmo,
4080 }
4081
4082 static_assertions::const_assert_eq!(std::mem::size_of::<FileGetBackingMemoryResponse>(), 4);
4083 static_assertions::const_assert_eq!(std::mem::align_of::<FileGetBackingMemoryResponse>(), 4);
4084
4085 static_assertions::const_assert_eq!(std::mem::offset_of!(FileGetBackingMemoryResponse, vmo), 0);
4086
4087 impl ::fidl_next::Constrained for FileGetBackingMemoryResponse {
4088 type Constraint = ();
4089
4090 fn validate(
4091 _: ::fidl_next::Slot<'_, Self>,
4092 _: Self::Constraint,
4093 ) -> Result<(), ::fidl_next::ValidationError> {
4094 Ok(())
4095 }
4096 }
4097
4098 unsafe impl ::fidl_next::Wire for FileGetBackingMemoryResponse {
4099 type Narrowed<'de> = FileGetBackingMemoryResponse;
4100
4101 #[inline]
4102 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4103 ::fidl_next::munge! {
4104 let Self {
4105 vmo,
4106
4107 } = &mut *out_;
4108 }
4109
4110 ::fidl_next::Wire::zero_padding(vmo);
4111 }
4112 }
4113
4114 unsafe impl<___D> ::fidl_next::Decode<___D> for FileGetBackingMemoryResponse
4115 where
4116 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4117 ___D: ::fidl_next::fuchsia::HandleDecoder,
4118 {
4119 fn decode(
4120 slot_: ::fidl_next::Slot<'_, Self>,
4121 decoder_: &mut ___D,
4122 _: (),
4123 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4124 ::fidl_next::munge! {
4125 let Self {
4126 mut vmo,
4127
4128 } = slot_;
4129 }
4130
4131 let _field = vmo.as_mut();
4132
4133 ::fidl_next::Decode::decode(vmo.as_mut(), decoder_, ())?;
4134
4135 Ok(())
4136 }
4137 }
4138
4139 impl ::fidl_next::IntoNatural for FileGetBackingMemoryResponse {
4140 type Natural = crate::natural::FileGetBackingMemoryResponse;
4141 }
4142
4143 #[derive(Debug)]
4145 #[repr(C)]
4146 pub struct LinkableLinkIntoRequest<'de> {
4147 pub dst_parent_token: ::fidl_next::wire::fuchsia::Event,
4148
4149 pub dst: ::fidl_next::wire::String<'de>,
4150 }
4151
4152 static_assertions::const_assert_eq!(std::mem::size_of::<LinkableLinkIntoRequest<'_>>(), 24);
4153 static_assertions::const_assert_eq!(std::mem::align_of::<LinkableLinkIntoRequest<'_>>(), 8);
4154
4155 static_assertions::const_assert_eq!(
4156 std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst_parent_token),
4157 0
4158 );
4159
4160 static_assertions::const_assert_eq!(std::mem::offset_of!(LinkableLinkIntoRequest<'_>, dst), 8);
4161
4162 impl ::fidl_next::Constrained for LinkableLinkIntoRequest<'_> {
4163 type Constraint = ();
4164
4165 fn validate(
4166 _: ::fidl_next::Slot<'_, Self>,
4167 _: Self::Constraint,
4168 ) -> Result<(), ::fidl_next::ValidationError> {
4169 Ok(())
4170 }
4171 }
4172
4173 unsafe impl ::fidl_next::Wire for LinkableLinkIntoRequest<'static> {
4174 type Narrowed<'de> = LinkableLinkIntoRequest<'de>;
4175
4176 #[inline]
4177 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4178 ::fidl_next::munge! {
4179 let Self {
4180 dst_parent_token,
4181 dst,
4182
4183 } = &mut *out_;
4184 }
4185
4186 ::fidl_next::Wire::zero_padding(dst_parent_token);
4187
4188 ::fidl_next::Wire::zero_padding(dst);
4189
4190 unsafe {
4191 out_.as_mut_ptr().cast::<u8>().add(4).write_bytes(0, 4);
4192 }
4193 }
4194 }
4195
4196 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for LinkableLinkIntoRequest<'de>
4197 where
4198 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4199 ___D: ::fidl_next::Decoder<'de>,
4200 ___D: ::fidl_next::fuchsia::HandleDecoder,
4201 {
4202 fn decode(
4203 slot_: ::fidl_next::Slot<'_, Self>,
4204 decoder_: &mut ___D,
4205 _: (),
4206 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4207 if slot_.as_bytes()[4..8] != [0u8; 4] {
4208 return Err(::fidl_next::DecodeError::InvalidPadding);
4209 }
4210
4211 ::fidl_next::munge! {
4212 let Self {
4213 mut dst_parent_token,
4214 mut dst,
4215
4216 } = slot_;
4217 }
4218
4219 let _field = dst_parent_token.as_mut();
4220
4221 ::fidl_next::Decode::decode(dst_parent_token.as_mut(), decoder_, ())?;
4222
4223 let _field = dst.as_mut();
4224 ::fidl_next::Constrained::validate(_field, 255)?;
4225 ::fidl_next::Decode::decode(dst.as_mut(), decoder_, 255)?;
4226
4227 let dst = unsafe { dst.deref_unchecked() };
4228
4229 if dst.len() > 255 {
4230 return Err(::fidl_next::DecodeError::VectorTooLong {
4231 size: dst.len() as u64,
4232 limit: 255,
4233 });
4234 }
4235
4236 Ok(())
4237 }
4238 }
4239
4240 impl<'de> ::fidl_next::IntoNatural for LinkableLinkIntoRequest<'de> {
4241 type Natural = crate::natural::LinkableLinkIntoRequest;
4242 }
4243
4244 #[derive(Debug)]
4246 #[repr(C)]
4247 pub struct FileAllocateRequest {
4248 pub offset: ::fidl_next::wire::Uint64,
4249
4250 pub length: ::fidl_next::wire::Uint64,
4251
4252 pub mode: crate::wire::AllocateMode,
4253 }
4254
4255 static_assertions::const_assert_eq!(std::mem::size_of::<FileAllocateRequest>(), 24);
4256 static_assertions::const_assert_eq!(std::mem::align_of::<FileAllocateRequest>(), 8);
4257
4258 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, offset), 0);
4259
4260 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, length), 8);
4261
4262 static_assertions::const_assert_eq!(std::mem::offset_of!(FileAllocateRequest, mode), 16);
4263
4264 impl ::fidl_next::Constrained for FileAllocateRequest {
4265 type Constraint = ();
4266
4267 fn validate(
4268 _: ::fidl_next::Slot<'_, Self>,
4269 _: Self::Constraint,
4270 ) -> Result<(), ::fidl_next::ValidationError> {
4271 Ok(())
4272 }
4273 }
4274
4275 unsafe impl ::fidl_next::Wire for FileAllocateRequest {
4276 type Narrowed<'de> = FileAllocateRequest;
4277
4278 #[inline]
4279 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4280 ::fidl_next::munge! {
4281 let Self {
4282 offset,
4283 length,
4284 mode,
4285
4286 } = &mut *out_;
4287 }
4288
4289 ::fidl_next::Wire::zero_padding(offset);
4290
4291 ::fidl_next::Wire::zero_padding(length);
4292
4293 ::fidl_next::Wire::zero_padding(mode);
4294
4295 unsafe {
4296 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4297 }
4298 }
4299 }
4300
4301 unsafe impl<___D> ::fidl_next::Decode<___D> for FileAllocateRequest
4302 where
4303 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4304 ___D: ::fidl_next::fuchsia::HandleDecoder,
4305 {
4306 fn decode(
4307 slot_: ::fidl_next::Slot<'_, Self>,
4308 decoder_: &mut ___D,
4309 _: (),
4310 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4311 if slot_.as_bytes()[20..24] != [0u8; 4] {
4312 return Err(::fidl_next::DecodeError::InvalidPadding);
4313 }
4314
4315 ::fidl_next::munge! {
4316 let Self {
4317 mut offset,
4318 mut length,
4319 mut mode,
4320
4321 } = slot_;
4322 }
4323
4324 let _field = offset.as_mut();
4325
4326 ::fidl_next::Decode::decode(offset.as_mut(), decoder_, ())?;
4327
4328 let _field = length.as_mut();
4329
4330 ::fidl_next::Decode::decode(length.as_mut(), decoder_, ())?;
4331
4332 let _field = mode.as_mut();
4333
4334 ::fidl_next::Decode::decode(mode.as_mut(), decoder_, ())?;
4335
4336 Ok(())
4337 }
4338 }
4339
4340 impl ::fidl_next::IntoNatural for FileAllocateRequest {
4341 type Natural = crate::natural::FileAllocateRequest;
4342 }
4343
4344 #[derive(Debug)]
4346 #[repr(C)]
4347 pub struct FileEnableVerityRequest<'de> {
4348 pub options: crate::wire::VerificationOptions<'de>,
4349 }
4350
4351 static_assertions::const_assert_eq!(std::mem::size_of::<FileEnableVerityRequest<'_>>(), 16);
4352 static_assertions::const_assert_eq!(std::mem::align_of::<FileEnableVerityRequest<'_>>(), 8);
4353
4354 static_assertions::const_assert_eq!(
4355 std::mem::offset_of!(FileEnableVerityRequest<'_>, options),
4356 0
4357 );
4358
4359 impl ::fidl_next::Constrained for FileEnableVerityRequest<'_> {
4360 type Constraint = ();
4361
4362 fn validate(
4363 _: ::fidl_next::Slot<'_, Self>,
4364 _: Self::Constraint,
4365 ) -> Result<(), ::fidl_next::ValidationError> {
4366 Ok(())
4367 }
4368 }
4369
4370 unsafe impl ::fidl_next::Wire for FileEnableVerityRequest<'static> {
4371 type Narrowed<'de> = FileEnableVerityRequest<'de>;
4372
4373 #[inline]
4374 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4375 ::fidl_next::munge! {
4376 let Self {
4377 options,
4378
4379 } = &mut *out_;
4380 }
4381
4382 ::fidl_next::Wire::zero_padding(options);
4383 }
4384 }
4385
4386 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for FileEnableVerityRequest<'de>
4387 where
4388 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4389 ___D: ::fidl_next::Decoder<'de>,
4390 ___D: ::fidl_next::fuchsia::HandleDecoder,
4391 {
4392 fn decode(
4393 slot_: ::fidl_next::Slot<'_, Self>,
4394 decoder_: &mut ___D,
4395 _: (),
4396 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4397 ::fidl_next::munge! {
4398 let Self {
4399 mut options,
4400
4401 } = slot_;
4402 }
4403
4404 let _field = options.as_mut();
4405
4406 ::fidl_next::Decode::decode(options.as_mut(), decoder_, ())?;
4407
4408 Ok(())
4409 }
4410 }
4411
4412 impl<'de> ::fidl_next::IntoNatural for FileEnableVerityRequest<'de> {
4413 type Natural = crate::natural::FileEnableVerityRequest;
4414 }
4415
4416 #[derive(Debug)]
4418 #[repr(C)]
4419 pub struct FileObject {
4420 pub event: ::fidl_next::wire::fuchsia::OptionalEvent,
4421
4422 pub stream: ::fidl_next::wire::fuchsia::OptionalStream,
4423 }
4424
4425 static_assertions::const_assert_eq!(std::mem::size_of::<FileObject>(), 8);
4426 static_assertions::const_assert_eq!(std::mem::align_of::<FileObject>(), 4);
4427
4428 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, event), 0);
4429
4430 static_assertions::const_assert_eq!(std::mem::offset_of!(FileObject, stream), 4);
4431
4432 impl ::fidl_next::Constrained for FileObject {
4433 type Constraint = ();
4434
4435 fn validate(
4436 _: ::fidl_next::Slot<'_, Self>,
4437 _: Self::Constraint,
4438 ) -> Result<(), ::fidl_next::ValidationError> {
4439 Ok(())
4440 }
4441 }
4442
4443 unsafe impl ::fidl_next::Wire for FileObject {
4444 type Narrowed<'de> = FileObject;
4445
4446 #[inline]
4447 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4448 ::fidl_next::munge! {
4449 let Self {
4450 event,
4451 stream,
4452
4453 } = &mut *out_;
4454 }
4455
4456 ::fidl_next::Wire::zero_padding(event);
4457
4458 ::fidl_next::Wire::zero_padding(stream);
4459 }
4460 }
4461
4462 unsafe impl<___D> ::fidl_next::Decode<___D> for FileObject
4463 where
4464 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4465 ___D: ::fidl_next::fuchsia::HandleDecoder,
4466 {
4467 fn decode(
4468 slot_: ::fidl_next::Slot<'_, Self>,
4469 decoder_: &mut ___D,
4470 _: (),
4471 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4472 ::fidl_next::munge! {
4473 let Self {
4474 mut event,
4475 mut stream,
4476
4477 } = slot_;
4478 }
4479
4480 let _field = event.as_mut();
4481
4482 ::fidl_next::Decode::decode(event.as_mut(), decoder_, ())?;
4483
4484 let _field = stream.as_mut();
4485
4486 ::fidl_next::Decode::decode(stream.as_mut(), decoder_, ())?;
4487
4488 Ok(())
4489 }
4490 }
4491
4492 impl ::fidl_next::IntoNatural for FileObject {
4493 type Natural = crate::natural::FileObject;
4494 }
4495
4496 #[repr(transparent)]
4498 pub struct NodeInfoDeprecated<'de> {
4499 pub(crate) raw: ::fidl_next::wire::Union,
4500 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4501 }
4502
4503 impl<'de> Drop for NodeInfoDeprecated<'de> {
4504 fn drop(&mut self) {
4505 match self.raw.ordinal() {
4506 1 => {
4507 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::Service>() };
4508 }
4509
4510 2 => {
4511 let _ = unsafe { self.raw.get().read_unchecked::<crate::wire::FileObject>() };
4512 }
4513
4514 3 => {
4515 let _ =
4516 unsafe { self.raw.get().read_unchecked::<crate::wire::DirectoryObject>() };
4517 }
4518
4519 4 => {
4520 let _ = unsafe {
4521 self.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4522 };
4523 }
4524
4525 _ => unsafe { ::core::hint::unreachable_unchecked() },
4526 }
4527 }
4528 }
4529
4530 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4531 type Constraint = ();
4532
4533 fn validate(
4534 _: ::fidl_next::Slot<'_, Self>,
4535 _: Self::Constraint,
4536 ) -> Result<(), ::fidl_next::ValidationError> {
4537 Ok(())
4538 }
4539 }
4540
4541 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4542 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4543
4544 #[inline]
4545 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4546 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4547 ::fidl_next::wire::Union::zero_padding(raw);
4548 }
4549 }
4550
4551 pub mod node_info_deprecated {
4552 pub enum Ref<'de> {
4553 Service(&'de crate::wire::Service),
4554
4555 File(&'de crate::wire::FileObject),
4556
4557 Directory(&'de crate::wire::DirectoryObject),
4558
4559 Symlink(&'de crate::wire::SymlinkObject<'de>),
4560 }
4561
4562 pub enum Value<'de> {
4563 Service(crate::wire::Service),
4564
4565 File(crate::wire::FileObject),
4566
4567 Directory(crate::wire::DirectoryObject),
4568
4569 Symlink(crate::wire::SymlinkObject<'de>),
4570 }
4571 }
4572
4573 impl<'de> NodeInfoDeprecated<'de> {
4574 pub fn as_ref(&self) -> crate::wire::node_info_deprecated::Ref<'_> {
4575 match self.raw.ordinal() {
4576 1 => crate::wire::node_info_deprecated::Ref::Service(unsafe {
4577 self.raw.get().deref_unchecked::<crate::wire::Service>()
4578 }),
4579
4580 2 => crate::wire::node_info_deprecated::Ref::File(unsafe {
4581 self.raw.get().deref_unchecked::<crate::wire::FileObject>()
4582 }),
4583
4584 3 => crate::wire::node_info_deprecated::Ref::Directory(unsafe {
4585 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>()
4586 }),
4587
4588 4 => crate::wire::node_info_deprecated::Ref::Symlink(unsafe {
4589 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>()
4590 }),
4591
4592 _ => unsafe { ::core::hint::unreachable_unchecked() },
4593 }
4594 }
4595
4596 pub fn into_inner(self) -> crate::wire::node_info_deprecated::Value<'de> {
4597 let this = ::core::mem::ManuallyDrop::new(self);
4598
4599 match this.raw.ordinal() {
4600 1 => crate::wire::node_info_deprecated::Value::Service(unsafe {
4601 this.raw.get().read_unchecked::<crate::wire::Service>()
4602 }),
4603
4604 2 => crate::wire::node_info_deprecated::Value::File(unsafe {
4605 this.raw.get().read_unchecked::<crate::wire::FileObject>()
4606 }),
4607
4608 3 => crate::wire::node_info_deprecated::Value::Directory(unsafe {
4609 this.raw.get().read_unchecked::<crate::wire::DirectoryObject>()
4610 }),
4611
4612 4 => crate::wire::node_info_deprecated::Value::Symlink(unsafe {
4613 this.raw.get().read_unchecked::<crate::wire::SymlinkObject<'de>>()
4614 }),
4615
4616 _ => unsafe { ::core::hint::unreachable_unchecked() },
4617 }
4618 }
4619 }
4620
4621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4622 where
4623 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4624 ___D: ::fidl_next::Decoder<'de>,
4625 ___D: ::fidl_next::fuchsia::HandleDecoder,
4626 {
4627 fn decode(
4628 mut slot: ::fidl_next::Slot<'_, Self>,
4629 decoder: &mut ___D,
4630 _: (),
4631 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4632 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4633 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4634 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4635 raw,
4636 decoder,
4637 (),
4638 )?,
4639
4640 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4641 raw,
4642 decoder,
4643 (),
4644 )?,
4645
4646 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4647 raw,
4648 decoder,
4649 (),
4650 )?,
4651
4652 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4653 raw,
4654 decoder,
4655 (),
4656 )?,
4657
4658 ord => return Err(::fidl_next::DecodeError::InvalidUnionOrdinal(ord as usize)),
4659 }
4660
4661 Ok(())
4662 }
4663 }
4664
4665 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4666 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4667 match self.raw.ordinal() {
4668 1 => unsafe { self.raw.get().deref_unchecked::<crate::wire::Service>().fmt(f) },
4669 2 => unsafe { self.raw.get().deref_unchecked::<crate::wire::FileObject>().fmt(f) },
4670 3 => unsafe {
4671 self.raw.get().deref_unchecked::<crate::wire::DirectoryObject>().fmt(f)
4672 },
4673 4 => unsafe {
4674 self.raw.get().deref_unchecked::<crate::wire::SymlinkObject<'_>>().fmt(f)
4675 },
4676 _ => unsafe { ::core::hint::unreachable_unchecked() },
4677 }
4678 }
4679 }
4680
4681 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
4682 type Natural = crate::natural::NodeInfoDeprecated;
4683 }
4684}
4685
4686pub mod wire_optional {
4687
4688 pub use fidl_next_common_fuchsia_io::wire_optional::*;
4689
4690 #[repr(transparent)]
4691 pub struct ExtendedAttributeValue<'de> {
4692 pub(crate) raw: ::fidl_next::wire::Union,
4693 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4694 }
4695
4696 impl ::fidl_next::Constrained for ExtendedAttributeValue<'_> {
4697 type Constraint = ();
4698
4699 fn validate(
4700 _: ::fidl_next::Slot<'_, Self>,
4701 _: Self::Constraint,
4702 ) -> Result<(), ::fidl_next::ValidationError> {
4703 Ok(())
4704 }
4705 }
4706
4707 unsafe impl ::fidl_next::Wire for ExtendedAttributeValue<'static> {
4708 type Narrowed<'de> = ExtendedAttributeValue<'de>;
4709
4710 #[inline]
4711 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4712 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4713 ::fidl_next::wire::Union::zero_padding(raw);
4714 }
4715 }
4716
4717 impl<'de> ExtendedAttributeValue<'de> {
4718 pub fn is_some(&self) -> bool {
4719 self.raw.is_some()
4720 }
4721
4722 pub fn is_none(&self) -> bool {
4723 self.raw.is_none()
4724 }
4725
4726 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::ExtendedAttributeValue<'de>> {
4727 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4728 }
4729
4730 pub fn into_option(
4731 self,
4732 ) -> ::core::option::Option<crate::wire::ExtendedAttributeValue<'de>> {
4733 if self.is_some() {
4734 Some(crate::wire::ExtendedAttributeValue {
4735 raw: self.raw,
4736 _phantom: ::core::marker::PhantomData,
4737 })
4738 } else {
4739 None
4740 }
4741 }
4742 }
4743
4744 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExtendedAttributeValue<'de>
4745 where
4746 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4747 ___D: ::fidl_next::Decoder<'de>,
4748 ___D: ::fidl_next::fuchsia::HandleDecoder,
4749 {
4750 fn decode(
4751 mut slot: ::fidl_next::Slot<'_, Self>,
4752 decoder: &mut ___D,
4753 _: (),
4754 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4755 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4756 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4757 1 => {
4758 ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::Vector<'de, u8>>(
4759 raw,
4760 decoder,
4761 (32768, ()),
4762 )?
4763 }
4764
4765 2 => ::fidl_next::wire::Union::decode_as::<___D, ::fidl_next::wire::fuchsia::Vmo>(
4766 raw,
4767 decoder,
4768 (),
4769 )?,
4770
4771 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4772 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4773 }
4774
4775 Ok(())
4776 }
4777 }
4778
4779 impl<'de> ::core::fmt::Debug for ExtendedAttributeValue<'de> {
4780 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4781 self.as_ref().fmt(f)
4782 }
4783 }
4784
4785 impl<'de> ::fidl_next::IntoNatural for ExtendedAttributeValue<'de> {
4786 type Natural = ::core::option::Option<crate::natural::ExtendedAttributeValue>;
4787 }
4788
4789 #[repr(transparent)]
4790 pub struct Representation<'de> {
4791 pub(crate) raw: ::fidl_next::wire::Union,
4792 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4793 }
4794
4795 impl ::fidl_next::Constrained for Representation<'_> {
4796 type Constraint = ();
4797
4798 fn validate(
4799 _: ::fidl_next::Slot<'_, Self>,
4800 _: Self::Constraint,
4801 ) -> Result<(), ::fidl_next::ValidationError> {
4802 Ok(())
4803 }
4804 }
4805
4806 unsafe impl ::fidl_next::Wire for Representation<'static> {
4807 type Narrowed<'de> = Representation<'de>;
4808
4809 #[inline]
4810 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4811 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4812 ::fidl_next::wire::Union::zero_padding(raw);
4813 }
4814 }
4815
4816 impl<'de> Representation<'de> {
4817 pub fn is_some(&self) -> bool {
4818 self.raw.is_some()
4819 }
4820
4821 pub fn is_none(&self) -> bool {
4822 self.raw.is_none()
4823 }
4824
4825 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::Representation<'de>> {
4826 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4827 }
4828
4829 pub fn into_option(self) -> ::core::option::Option<crate::wire::Representation<'de>> {
4830 if self.is_some() {
4831 Some(crate::wire::Representation {
4832 raw: self.raw,
4833 _phantom: ::core::marker::PhantomData,
4834 })
4835 } else {
4836 None
4837 }
4838 }
4839 }
4840
4841 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Representation<'de>
4842 where
4843 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4844 ___D: ::fidl_next::Decoder<'de>,
4845 ___D: ::fidl_next::fuchsia::HandleDecoder,
4846 {
4847 fn decode(
4848 mut slot: ::fidl_next::Slot<'_, Self>,
4849 decoder: &mut ___D,
4850 _: (),
4851 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4852 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4853 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4854 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::NodeInfo<'de>>(
4855 raw,
4856 decoder,
4857 (),
4858 )?,
4859
4860 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryInfo<'de>>(
4861 raw,
4862 decoder,
4863 (),
4864 )?,
4865
4866 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileInfo<'de>>(
4867 raw,
4868 decoder,
4869 (),
4870 )?,
4871
4872 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkInfo<'de>>(
4873 raw,
4874 decoder,
4875 (),
4876 )?,
4877
4878 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4879 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4880 }
4881
4882 Ok(())
4883 }
4884 }
4885
4886 impl<'de> ::core::fmt::Debug for Representation<'de> {
4887 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4888 self.as_ref().fmt(f)
4889 }
4890 }
4891
4892 impl<'de> ::fidl_next::IntoNatural for Representation<'de> {
4893 type Natural = ::core::option::Option<crate::natural::Representation>;
4894 }
4895
4896 #[repr(transparent)]
4897 pub struct NodeInfoDeprecated<'de> {
4898 pub(crate) raw: ::fidl_next::wire::Union,
4899 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4900 }
4901
4902 impl ::fidl_next::Constrained for NodeInfoDeprecated<'_> {
4903 type Constraint = ();
4904
4905 fn validate(
4906 _: ::fidl_next::Slot<'_, Self>,
4907 _: Self::Constraint,
4908 ) -> Result<(), ::fidl_next::ValidationError> {
4909 Ok(())
4910 }
4911 }
4912
4913 unsafe impl ::fidl_next::Wire for NodeInfoDeprecated<'static> {
4914 type Narrowed<'de> = NodeInfoDeprecated<'de>;
4915
4916 #[inline]
4917 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4918 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4919 ::fidl_next::wire::Union::zero_padding(raw);
4920 }
4921 }
4922
4923 impl<'de> NodeInfoDeprecated<'de> {
4924 pub fn is_some(&self) -> bool {
4925 self.raw.is_some()
4926 }
4927
4928 pub fn is_none(&self) -> bool {
4929 self.raw.is_none()
4930 }
4931
4932 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::NodeInfoDeprecated<'de>> {
4933 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
4934 }
4935
4936 pub fn into_option(self) -> ::core::option::Option<crate::wire::NodeInfoDeprecated<'de>> {
4937 if self.is_some() {
4938 Some(crate::wire::NodeInfoDeprecated {
4939 raw: self.raw,
4940 _phantom: ::core::marker::PhantomData,
4941 })
4942 } else {
4943 None
4944 }
4945 }
4946 }
4947
4948 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NodeInfoDeprecated<'de>
4949 where
4950 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4951 ___D: ::fidl_next::Decoder<'de>,
4952 ___D: ::fidl_next::fuchsia::HandleDecoder,
4953 {
4954 fn decode(
4955 mut slot: ::fidl_next::Slot<'_, Self>,
4956 decoder: &mut ___D,
4957 _: (),
4958 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4959 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4960 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4961 1 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::Service>(
4962 raw,
4963 decoder,
4964 (),
4965 )?,
4966
4967 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::FileObject>(
4968 raw,
4969 decoder,
4970 (),
4971 )?,
4972
4973 3 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DirectoryObject>(
4974 raw,
4975 decoder,
4976 (),
4977 )?,
4978
4979 4 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::SymlinkObject<'de>>(
4980 raw,
4981 decoder,
4982 (),
4983 )?,
4984
4985 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
4986 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4987 }
4988
4989 Ok(())
4990 }
4991 }
4992
4993 impl<'de> ::core::fmt::Debug for NodeInfoDeprecated<'de> {
4994 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4995 self.as_ref().fmt(f)
4996 }
4997 }
4998
4999 impl<'de> ::fidl_next::IntoNatural for NodeInfoDeprecated<'de> {
5000 type Natural = ::core::option::Option<crate::natural::NodeInfoDeprecated>;
5001 }
5002}
5003
5004pub mod generic {
5005
5006 pub use fidl_next_common_fuchsia_io::generic::*;
5007
5008 pub struct DirectoryLinkRequest<T0, T1, T2> {
5010 pub src: T0,
5011
5012 pub dst_parent_token: T1,
5013
5014 pub dst: T2,
5015 }
5016
5017 unsafe impl<___E, T0, T1, T2>
5018 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
5019 for DirectoryLinkRequest<T0, T1, T2>
5020 where
5021 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5022 ___E: ::fidl_next::Encoder,
5023 ___E: ::fidl_next::fuchsia::HandleEncoder,
5024 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5025 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
5026 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5027 {
5028 #[inline]
5029 fn encode(
5030 self,
5031 encoder_: &mut ___E,
5032 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
5033 _: (),
5034 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5035 ::fidl_next::munge! {
5036 let crate::wire::DirectoryLinkRequest {
5037 src,
5038 dst_parent_token,
5039 dst,
5040
5041 } = out_;
5042 }
5043
5044 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5045
5046 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5047
5048 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5049
5050 Ok(())
5051 }
5052 }
5053
5054 unsafe impl<'a, ___E, T0, T1, T2>
5055 ::fidl_next::Encode<crate::wire::DirectoryLinkRequest<'static>, ___E>
5056 for &'a DirectoryLinkRequest<T0, T1, T2>
5057 where
5058 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5059 ___E: ::fidl_next::Encoder,
5060 ___E: ::fidl_next::fuchsia::HandleEncoder,
5061 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5062 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::NullableHandle, ___E>,
5063 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5064 {
5065 #[inline]
5066 fn encode(
5067 self,
5068 encoder_: &mut ___E,
5069 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryLinkRequest<'static>>,
5070 _: (),
5071 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5072 ::fidl_next::munge! {
5073 let crate::wire::DirectoryLinkRequest {
5074 src,
5075 dst_parent_token,
5076 dst,
5077
5078 } = out_;
5079 }
5080
5081 ::fidl_next::Encode::encode(&self.src, encoder_, src, 255)?;
5082
5083 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
5084
5085 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
5086
5087 Ok(())
5088 }
5089 }
5090
5091 pub struct DirectoryRenameRequest<T0, T1, T2> {
5093 pub src: T0,
5094
5095 pub dst_parent_token: T1,
5096
5097 pub dst: T2,
5098 }
5099
5100 unsafe impl<___E, T0, T1, T2>
5101 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5102 for DirectoryRenameRequest<T0, T1, T2>
5103 where
5104 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5105 ___E: ::fidl_next::Encoder,
5106 ___E: ::fidl_next::fuchsia::HandleEncoder,
5107 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5108 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5109 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5110 {
5111 #[inline]
5112 fn encode(
5113 self,
5114 encoder_: &mut ___E,
5115 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5116 _: (),
5117 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5118 ::fidl_next::munge! {
5119 let crate::wire::DirectoryRenameRequest {
5120 src,
5121 dst_parent_token,
5122 dst,
5123
5124 } = out_;
5125 }
5126
5127 ::fidl_next::Encode::encode(self.src, encoder_, src, 255)?;
5128
5129 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
5130
5131 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
5132
5133 Ok(())
5134 }
5135 }
5136
5137 unsafe impl<'a, ___E, T0, T1, T2>
5138 ::fidl_next::Encode<crate::wire::DirectoryRenameRequest<'static>, ___E>
5139 for &'a DirectoryRenameRequest<T0, T1, T2>
5140 where
5141 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5142 ___E: ::fidl_next::Encoder,
5143 ___E: ::fidl_next::fuchsia::HandleEncoder,
5144 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5145 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5146 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5147 {
5148 #[inline]
5149 fn encode(
5150 self,
5151 encoder_: &mut ___E,
5152 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryRenameRequest<'static>>,
5153 _: (),
5154 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5155 ::fidl_next::munge! {
5156 let crate::wire::DirectoryRenameRequest {
5157 src,
5158 dst_parent_token,
5159 dst,
5160
5161 } = out_;
5162 }
5163
5164 ::fidl_next::Encode::encode(&self.src, encoder_, src, 255)?;
5165
5166 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
5167
5168 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
5169
5170 Ok(())
5171 }
5172 }
5173
5174 pub struct DirectoryWatchRequest<T0, T1, T2> {
5176 pub mask: T0,
5177
5178 pub options: T1,
5179
5180 pub watcher: T2,
5181 }
5182
5183 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5184 for DirectoryWatchRequest<T0, T1, T2>
5185 where
5186 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5187 ___E: ::fidl_next::fuchsia::HandleEncoder,
5188 T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5189 T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5190 T2: ::fidl_next::Encode<
5191 ::fidl_next::ServerEnd<
5192 crate::DirectoryWatcher,
5193 ::fidl_next::wire::fuchsia::Channel,
5194 >,
5195 ___E,
5196 >,
5197 {
5198 #[inline]
5199 fn encode(
5200 self,
5201 encoder_: &mut ___E,
5202 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5203 _: (),
5204 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5205 ::fidl_next::munge! {
5206 let crate::wire::DirectoryWatchRequest {
5207 mask,
5208 options,
5209 watcher,
5210
5211 } = out_;
5212 }
5213
5214 ::fidl_next::Encode::encode(self.mask, encoder_, mask, ())?;
5215
5216 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5217
5218 ::fidl_next::Encode::encode(self.watcher, encoder_, watcher, ())?;
5219
5220 Ok(())
5221 }
5222 }
5223
5224 unsafe impl<'a, ___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::DirectoryWatchRequest, ___E>
5225 for &'a DirectoryWatchRequest<T0, T1, T2>
5226 where
5227 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5228 ___E: ::fidl_next::fuchsia::HandleEncoder,
5229 &'a T0: ::fidl_next::Encode<crate::wire::WatchMask, ___E>,
5230 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint32, ___E>,
5231 &'a T2: ::fidl_next::Encode<
5232 ::fidl_next::ServerEnd<
5233 crate::DirectoryWatcher,
5234 ::fidl_next::wire::fuchsia::Channel,
5235 >,
5236 ___E,
5237 >,
5238 {
5239 #[inline]
5240 fn encode(
5241 self,
5242 encoder_: &mut ___E,
5243 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryWatchRequest>,
5244 _: (),
5245 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5246 ::fidl_next::munge! {
5247 let crate::wire::DirectoryWatchRequest {
5248 mask,
5249 options,
5250 watcher,
5251
5252 } = out_;
5253 }
5254
5255 ::fidl_next::Encode::encode(&self.mask, encoder_, mask, ())?;
5256
5257 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
5258
5259 ::fidl_next::Encode::encode(&self.watcher, encoder_, watcher, ())?;
5260
5261 Ok(())
5262 }
5263 }
5264
5265 pub struct NodeListExtendedAttributesRequest<T0> {
5267 pub iterator: T0,
5268 }
5269
5270 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5271 for NodeListExtendedAttributesRequest<T0>
5272 where
5273 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5274 ___E: ::fidl_next::fuchsia::HandleEncoder,
5275 T0: ::fidl_next::Encode<
5276 ::fidl_next::ServerEnd<
5277 crate::ExtendedAttributeIterator,
5278 ::fidl_next::wire::fuchsia::Channel,
5279 >,
5280 ___E,
5281 >,
5282 {
5283 #[inline]
5284 fn encode(
5285 self,
5286 encoder_: &mut ___E,
5287 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5288 _: (),
5289 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5290 ::fidl_next::munge! {
5291 let crate::wire::NodeListExtendedAttributesRequest {
5292 iterator,
5293
5294 } = out_;
5295 }
5296
5297 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
5298
5299 Ok(())
5300 }
5301 }
5302
5303 unsafe impl<'a, ___E, T0>
5304 ::fidl_next::Encode<crate::wire::NodeListExtendedAttributesRequest, ___E>
5305 for &'a NodeListExtendedAttributesRequest<T0>
5306 where
5307 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5308 ___E: ::fidl_next::fuchsia::HandleEncoder,
5309 &'a T0: ::fidl_next::Encode<
5310 ::fidl_next::ServerEnd<
5311 crate::ExtendedAttributeIterator,
5312 ::fidl_next::wire::fuchsia::Channel,
5313 >,
5314 ___E,
5315 >,
5316 {
5317 #[inline]
5318 fn encode(
5319 self,
5320 encoder_: &mut ___E,
5321 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeListExtendedAttributesRequest>,
5322 _: (),
5323 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5324 ::fidl_next::munge! {
5325 let crate::wire::NodeListExtendedAttributesRequest {
5326 iterator,
5327
5328 } = out_;
5329 }
5330
5331 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
5332
5333 Ok(())
5334 }
5335 }
5336
5337 pub struct NodeSetExtendedAttributeRequest<T0, T1, T2> {
5339 pub name: T0,
5340
5341 pub value: T1,
5342
5343 pub mode: T2,
5344 }
5345
5346 unsafe impl<___E, T0, T1, T2>
5347 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5348 for NodeSetExtendedAttributeRequest<T0, T1, T2>
5349 where
5350 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5351 ___E: ::fidl_next::Encoder,
5352 ___E: ::fidl_next::fuchsia::HandleEncoder,
5353 T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5354 T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5355 T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5356 {
5357 #[inline]
5358 fn encode(
5359 self,
5360 encoder_: &mut ___E,
5361 out_: &mut ::core::mem::MaybeUninit<
5362 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5363 >,
5364 _: (),
5365 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5366 ::fidl_next::munge! {
5367 let crate::wire::NodeSetExtendedAttributeRequest {
5368 name,
5369 value,
5370 mode,
5371
5372 } = out_;
5373 }
5374
5375 ::fidl_next::Encode::encode(self.name, encoder_, name, (255, ()))?;
5376
5377 ::fidl_next::Encode::encode(self.value, encoder_, value, ())?;
5378
5379 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5380
5381 Ok(())
5382 }
5383 }
5384
5385 unsafe impl<'a, ___E, T0, T1, T2>
5386 ::fidl_next::Encode<crate::wire::NodeSetExtendedAttributeRequest<'static>, ___E>
5387 for &'a NodeSetExtendedAttributeRequest<T0, T1, T2>
5388 where
5389 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5390 ___E: ::fidl_next::Encoder,
5391 ___E: ::fidl_next::fuchsia::HandleEncoder,
5392 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5393 &'a T1: ::fidl_next::Encode<crate::wire::ExtendedAttributeValue<'static>, ___E>,
5394 &'a T2: ::fidl_next::Encode<crate::wire::SetExtendedAttributeMode, ___E>,
5395 {
5396 #[inline]
5397 fn encode(
5398 self,
5399 encoder_: &mut ___E,
5400 out_: &mut ::core::mem::MaybeUninit<
5401 crate::wire::NodeSetExtendedAttributeRequest<'static>,
5402 >,
5403 _: (),
5404 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5405 ::fidl_next::munge! {
5406 let crate::wire::NodeSetExtendedAttributeRequest {
5407 name,
5408 value,
5409 mode,
5410
5411 } = out_;
5412 }
5413
5414 ::fidl_next::Encode::encode(&self.name, encoder_, name, (255, ()))?;
5415
5416 ::fidl_next::Encode::encode(&self.value, encoder_, value, ())?;
5417
5418 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
5419
5420 Ok(())
5421 }
5422 }
5423
5424 pub struct NodeGetTokenResponse<T0> {
5426 pub token: T0,
5427 }
5428
5429 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
5430 for NodeGetTokenResponse<T0>
5431 where
5432 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5433 ___E: ::fidl_next::fuchsia::HandleEncoder,
5434 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5435 {
5436 #[inline]
5437 fn encode(
5438 self,
5439 encoder_: &mut ___E,
5440 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
5441 _: (),
5442 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5443 ::fidl_next::munge! {
5444 let crate::wire::NodeGetTokenResponse {
5445 token,
5446
5447 } = out_;
5448 }
5449
5450 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5451
5452 Ok(())
5453 }
5454 }
5455
5456 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::NodeGetTokenResponse, ___E>
5457 for &'a NodeGetTokenResponse<T0>
5458 where
5459 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5460 ___E: ::fidl_next::fuchsia::HandleEncoder,
5461 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5462 {
5463 #[inline]
5464 fn encode(
5465 self,
5466 encoder_: &mut ___E,
5467 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeGetTokenResponse>,
5468 _: (),
5469 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5470 ::fidl_next::munge! {
5471 let crate::wire::NodeGetTokenResponse {
5472 token,
5473
5474 } = out_;
5475 }
5476
5477 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
5478
5479 Ok(())
5480 }
5481 }
5482
5483 pub struct DirectoryDeprecatedGetTokenResponse<T0, T1> {
5485 pub s: T0,
5486
5487 pub token: T1,
5488 }
5489
5490 unsafe impl<___E, T0, T1>
5491 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
5492 for DirectoryDeprecatedGetTokenResponse<T0, T1>
5493 where
5494 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5495 ___E: ::fidl_next::fuchsia::HandleEncoder,
5496 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5497 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
5498 {
5499 #[inline]
5500 fn encode(
5501 self,
5502 encoder_: &mut ___E,
5503 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
5504 _: (),
5505 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5506 ::fidl_next::munge! {
5507 let crate::wire::DirectoryDeprecatedGetTokenResponse {
5508 s,
5509 token,
5510
5511 } = out_;
5512 }
5513
5514 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5515
5516 ::fidl_next::Encode::encode(self.token, encoder_, token, ())?;
5517
5518 Ok(())
5519 }
5520 }
5521
5522 unsafe impl<'a, ___E, T0, T1>
5523 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedGetTokenResponse, ___E>
5524 for &'a DirectoryDeprecatedGetTokenResponse<T0, T1>
5525 where
5526 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5527 ___E: ::fidl_next::fuchsia::HandleEncoder,
5528 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5529 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalNullableHandle, ___E>,
5530 {
5531 #[inline]
5532 fn encode(
5533 self,
5534 encoder_: &mut ___E,
5535 out_: &mut ::core::mem::MaybeUninit<crate::wire::DirectoryDeprecatedGetTokenResponse>,
5536 _: (),
5537 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5538 ::fidl_next::munge! {
5539 let crate::wire::DirectoryDeprecatedGetTokenResponse {
5540 s,
5541 token,
5542
5543 } = out_;
5544 }
5545
5546 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
5547
5548 ::fidl_next::Encode::encode(&self.token, encoder_, token, ())?;
5549
5550 Ok(())
5551 }
5552 }
5553
5554 pub struct OpenableOpenRequest<T0, T1, T2, T3> {
5556 pub path: T0,
5557
5558 pub flags: T1,
5559
5560 pub options: T2,
5561
5562 pub object: T3,
5563 }
5564
5565 unsafe impl<___E, T0, T1, T2, T3>
5566 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5567 for OpenableOpenRequest<T0, T1, T2, T3>
5568 where
5569 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5570 ___E: ::fidl_next::Encoder,
5571 ___E: ::fidl_next::fuchsia::HandleEncoder,
5572 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5573 T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5574 T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5575 T3: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
5576 {
5577 #[inline]
5578 fn encode(
5579 self,
5580 encoder_: &mut ___E,
5581 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5582 _: (),
5583 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5584 ::fidl_next::munge! {
5585 let crate::wire::OpenableOpenRequest {
5586 path,
5587 flags,
5588 options,
5589 object,
5590
5591 } = out_;
5592 }
5593
5594 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5595
5596 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5597
5598 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
5599
5600 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5601
5602 Ok(())
5603 }
5604 }
5605
5606 unsafe impl<'a, ___E, T0, T1, T2, T3>
5607 ::fidl_next::Encode<crate::wire::OpenableOpenRequest<'static>, ___E>
5608 for &'a OpenableOpenRequest<T0, T1, T2, T3>
5609 where
5610 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5611 ___E: ::fidl_next::Encoder,
5612 ___E: ::fidl_next::fuchsia::HandleEncoder,
5613 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5614 &'a T1: ::fidl_next::Encode<crate::wire::Flags, ___E>,
5615 &'a T2: ::fidl_next::Encode<crate::wire::Options<'static>, ___E>,
5616 &'a T3: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Channel, ___E>,
5617 {
5618 #[inline]
5619 fn encode(
5620 self,
5621 encoder_: &mut ___E,
5622 out_: &mut ::core::mem::MaybeUninit<crate::wire::OpenableOpenRequest<'static>>,
5623 _: (),
5624 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5625 ::fidl_next::munge! {
5626 let crate::wire::OpenableOpenRequest {
5627 path,
5628 flags,
5629 options,
5630 object,
5631
5632 } = out_;
5633 }
5634
5635 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
5636
5637 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5638
5639 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
5640
5641 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
5642
5643 Ok(())
5644 }
5645 }
5646
5647 pub struct NodeOnOpenRequest<T0, T1> {
5649 pub s: T0,
5650
5651 pub info: T1,
5652 }
5653
5654 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5655 for NodeOnOpenRequest<T0, T1>
5656 where
5657 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5658 ___E: ::fidl_next::Encoder,
5659 ___E: ::fidl_next::fuchsia::HandleEncoder,
5660 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5661 T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5662 {
5663 #[inline]
5664 fn encode(
5665 self,
5666 encoder_: &mut ___E,
5667 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5668 _: (),
5669 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5670 ::fidl_next::munge! {
5671 let crate::wire::NodeOnOpenRequest {
5672 s,
5673 info,
5674
5675 } = out_;
5676 }
5677
5678 ::fidl_next::Encode::encode(self.s, encoder_, s, ())?;
5679
5680 ::fidl_next::Encode::encode(self.info, encoder_, info, ())?;
5681
5682 Ok(())
5683 }
5684 }
5685
5686 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::NodeOnOpenRequest<'static>, ___E>
5687 for &'a NodeOnOpenRequest<T0, T1>
5688 where
5689 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5690 ___E: ::fidl_next::Encoder,
5691 ___E: ::fidl_next::fuchsia::HandleEncoder,
5692 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::StatusResult, ___E>,
5693 &'a T1: ::fidl_next::Encode<crate::wire_optional::NodeInfoDeprecated<'static>, ___E>,
5694 {
5695 #[inline]
5696 fn encode(
5697 self,
5698 encoder_: &mut ___E,
5699 out_: &mut ::core::mem::MaybeUninit<crate::wire::NodeOnOpenRequest<'static>>,
5700 _: (),
5701 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5702 ::fidl_next::munge! {
5703 let crate::wire::NodeOnOpenRequest {
5704 s,
5705 info,
5706
5707 } = out_;
5708 }
5709
5710 ::fidl_next::Encode::encode(&self.s, encoder_, s, ())?;
5711
5712 ::fidl_next::Encode::encode(&self.info, encoder_, info, ())?;
5713
5714 Ok(())
5715 }
5716 }
5717
5718 pub struct DirectoryDeprecatedOpenRequest<T0, T1, T2, T3> {
5720 pub flags: T0,
5721
5722 pub mode: T1,
5723
5724 pub path: T2,
5725
5726 pub object: T3,
5727 }
5728
5729 unsafe impl<___E, T0, T1, T2, T3>
5730 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5731 for DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5732 where
5733 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5734 ___E: ::fidl_next::Encoder,
5735 ___E: ::fidl_next::fuchsia::HandleEncoder,
5736 T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5737 T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5738 T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5739 T3: ::fidl_next::Encode<
5740 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
5741 ___E,
5742 >,
5743 {
5744 #[inline]
5745 fn encode(
5746 self,
5747 encoder_: &mut ___E,
5748 out_: &mut ::core::mem::MaybeUninit<
5749 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5750 >,
5751 _: (),
5752 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5753 ::fidl_next::munge! {
5754 let crate::wire::DirectoryDeprecatedOpenRequest {
5755 flags,
5756 mode,
5757 path,
5758 object,
5759
5760 } = out_;
5761 }
5762
5763 ::fidl_next::Encode::encode(self.flags, encoder_, flags, ())?;
5764
5765 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
5766
5767 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
5768
5769 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
5770
5771 Ok(())
5772 }
5773 }
5774
5775 unsafe impl<'a, ___E, T0, T1, T2, T3>
5776 ::fidl_next::Encode<crate::wire::DirectoryDeprecatedOpenRequest<'static>, ___E>
5777 for &'a DirectoryDeprecatedOpenRequest<T0, T1, T2, T3>
5778 where
5779 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5780 ___E: ::fidl_next::Encoder,
5781 ___E: ::fidl_next::fuchsia::HandleEncoder,
5782 &'a T0: ::fidl_next::Encode<crate::wire::OpenFlags, ___E>,
5783 &'a T1: ::fidl_next::Encode<crate::wire::ModeType, ___E>,
5784 &'a T2: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5785 &'a T3: ::fidl_next::Encode<
5786 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
5787 ___E,
5788 >,
5789 {
5790 #[inline]
5791 fn encode(
5792 self,
5793 encoder_: &mut ___E,
5794 out_: &mut ::core::mem::MaybeUninit<
5795 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
5796 >,
5797 _: (),
5798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5799 ::fidl_next::munge! {
5800 let crate::wire::DirectoryDeprecatedOpenRequest {
5801 flags,
5802 mode,
5803 path,
5804 object,
5805
5806 } = out_;
5807 }
5808
5809 ::fidl_next::Encode::encode(&self.flags, encoder_, flags, ())?;
5810
5811 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
5812
5813 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
5814
5815 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
5816
5817 Ok(())
5818 }
5819 }
5820
5821 pub struct DirectoryCreateSymlinkRequest<T0, T1, T2> {
5823 pub name: T0,
5824
5825 pub target: T1,
5826
5827 pub connection: T2,
5828 }
5829
5830 unsafe impl<___E, T0, T1, T2>
5831 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5832 for DirectoryCreateSymlinkRequest<T0, T1, T2>
5833 where
5834 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5835 ___E: ::fidl_next::Encoder,
5836 ___E: ::fidl_next::fuchsia::HandleEncoder,
5837 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5838 T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5839 T2: ::fidl_next::Encode<
5840 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::wire::fuchsia::OptionalChannel>,
5841 ___E,
5842 >,
5843 {
5844 #[inline]
5845 fn encode(
5846 self,
5847 encoder_: &mut ___E,
5848 out_: &mut ::core::mem::MaybeUninit<
5849 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5850 >,
5851 _: (),
5852 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5853 ::fidl_next::munge! {
5854 let crate::wire::DirectoryCreateSymlinkRequest {
5855 name,
5856 target,
5857 connection,
5858
5859 } = out_;
5860 }
5861
5862 ::fidl_next::Encode::encode(self.name, encoder_, name, 255)?;
5863
5864 ::fidl_next::Encode::encode(self.target, encoder_, target, (4095, ()))?;
5865
5866 ::fidl_next::Encode::encode(self.connection, encoder_, connection, ())?;
5867
5868 Ok(())
5869 }
5870 }
5871
5872 unsafe impl<'a, ___E, T0, T1, T2>
5873 ::fidl_next::Encode<crate::wire::DirectoryCreateSymlinkRequest<'static>, ___E>
5874 for &'a DirectoryCreateSymlinkRequest<T0, T1, T2>
5875 where
5876 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5877 ___E: ::fidl_next::Encoder,
5878 ___E: ::fidl_next::fuchsia::HandleEncoder,
5879 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5880 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, u8>, ___E>,
5881 &'a T2: ::fidl_next::Encode<
5882 ::fidl_next::ServerEnd<crate::Symlink, ::fidl_next::wire::fuchsia::OptionalChannel>,
5883 ___E,
5884 >,
5885 {
5886 #[inline]
5887 fn encode(
5888 self,
5889 encoder_: &mut ___E,
5890 out_: &mut ::core::mem::MaybeUninit<
5891 crate::wire::DirectoryCreateSymlinkRequest<'static>,
5892 >,
5893 _: (),
5894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5895 ::fidl_next::munge! {
5896 let crate::wire::DirectoryCreateSymlinkRequest {
5897 name,
5898 target,
5899 connection,
5900
5901 } = out_;
5902 }
5903
5904 ::fidl_next::Encode::encode(&self.name, encoder_, name, 255)?;
5905
5906 ::fidl_next::Encode::encode(&self.target, encoder_, target, (4095, ()))?;
5907
5908 ::fidl_next::Encode::encode(&self.connection, encoder_, connection, ())?;
5909
5910 Ok(())
5911 }
5912 }
5913
5914 pub struct FileGetBackingMemoryResponse<T0> {
5916 pub vmo: T0,
5917 }
5918
5919 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5920 for FileGetBackingMemoryResponse<T0>
5921 where
5922 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5923 ___E: ::fidl_next::fuchsia::HandleEncoder,
5924 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
5925 {
5926 #[inline]
5927 fn encode(
5928 self,
5929 encoder_: &mut ___E,
5930 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5931 _: (),
5932 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5933 ::fidl_next::munge! {
5934 let crate::wire::FileGetBackingMemoryResponse {
5935 vmo,
5936
5937 } = out_;
5938 }
5939
5940 ::fidl_next::Encode::encode(self.vmo, encoder_, vmo, ())?;
5941
5942 Ok(())
5943 }
5944 }
5945
5946 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::FileGetBackingMemoryResponse, ___E>
5947 for &'a FileGetBackingMemoryResponse<T0>
5948 where
5949 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5950 ___E: ::fidl_next::fuchsia::HandleEncoder,
5951 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Vmo, ___E>,
5952 {
5953 #[inline]
5954 fn encode(
5955 self,
5956 encoder_: &mut ___E,
5957 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileGetBackingMemoryResponse>,
5958 _: (),
5959 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5960 ::fidl_next::munge! {
5961 let crate::wire::FileGetBackingMemoryResponse {
5962 vmo,
5963
5964 } = out_;
5965 }
5966
5967 ::fidl_next::Encode::encode(&self.vmo, encoder_, vmo, ())?;
5968
5969 Ok(())
5970 }
5971 }
5972
5973 pub struct LinkableLinkIntoRequest<T0, T1> {
5975 pub dst_parent_token: T0,
5976
5977 pub dst: T1,
5978 }
5979
5980 unsafe impl<___E, T0, T1>
5981 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
5982 for LinkableLinkIntoRequest<T0, T1>
5983 where
5984 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
5985 ___E: ::fidl_next::Encoder,
5986 ___E: ::fidl_next::fuchsia::HandleEncoder,
5987 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
5988 T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
5989 {
5990 #[inline]
5991 fn encode(
5992 self,
5993 encoder_: &mut ___E,
5994 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
5995 _: (),
5996 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
5997 ::fidl_next::munge! {
5998 let crate::wire::LinkableLinkIntoRequest {
5999 dst_parent_token,
6000 dst,
6001
6002 } = out_;
6003 }
6004
6005 ::fidl_next::Encode::encode(self.dst_parent_token, encoder_, dst_parent_token, ())?;
6006
6007 ::fidl_next::Encode::encode(self.dst, encoder_, dst, 255)?;
6008
6009 Ok(())
6010 }
6011 }
6012
6013 unsafe impl<'a, ___E, T0, T1>
6014 ::fidl_next::Encode<crate::wire::LinkableLinkIntoRequest<'static>, ___E>
6015 for &'a LinkableLinkIntoRequest<T0, T1>
6016 where
6017 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6018 ___E: ::fidl_next::Encoder,
6019 ___E: ::fidl_next::fuchsia::HandleEncoder,
6020 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
6021 &'a T1: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
6022 {
6023 #[inline]
6024 fn encode(
6025 self,
6026 encoder_: &mut ___E,
6027 out_: &mut ::core::mem::MaybeUninit<crate::wire::LinkableLinkIntoRequest<'static>>,
6028 _: (),
6029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6030 ::fidl_next::munge! {
6031 let crate::wire::LinkableLinkIntoRequest {
6032 dst_parent_token,
6033 dst,
6034
6035 } = out_;
6036 }
6037
6038 ::fidl_next::Encode::encode(&self.dst_parent_token, encoder_, dst_parent_token, ())?;
6039
6040 ::fidl_next::Encode::encode(&self.dst, encoder_, dst, 255)?;
6041
6042 Ok(())
6043 }
6044 }
6045
6046 pub struct FileAllocateRequest<T0, T1, T2> {
6048 pub offset: T0,
6049
6050 pub length: T1,
6051
6052 pub mode: T2,
6053 }
6054
6055 unsafe impl<___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
6056 for FileAllocateRequest<T0, T1, T2>
6057 where
6058 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6059 ___E: ::fidl_next::fuchsia::HandleEncoder,
6060 T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6061 T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6062 T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
6063 {
6064 #[inline]
6065 fn encode(
6066 self,
6067 encoder_: &mut ___E,
6068 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
6069 _: (),
6070 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6071 ::fidl_next::munge! {
6072 let crate::wire::FileAllocateRequest {
6073 offset,
6074 length,
6075 mode,
6076
6077 } = out_;
6078 }
6079
6080 ::fidl_next::Encode::encode(self.offset, encoder_, offset, ())?;
6081
6082 ::fidl_next::Encode::encode(self.length, encoder_, length, ())?;
6083
6084 ::fidl_next::Encode::encode(self.mode, encoder_, mode, ())?;
6085
6086 Ok(())
6087 }
6088 }
6089
6090 unsafe impl<'a, ___E, T0, T1, T2> ::fidl_next::Encode<crate::wire::FileAllocateRequest, ___E>
6091 for &'a FileAllocateRequest<T0, T1, T2>
6092 where
6093 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6094 ___E: ::fidl_next::fuchsia::HandleEncoder,
6095 &'a T0: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6096 &'a T1: ::fidl_next::Encode<::fidl_next::wire::Uint64, ___E>,
6097 &'a T2: ::fidl_next::Encode<crate::wire::AllocateMode, ___E>,
6098 {
6099 #[inline]
6100 fn encode(
6101 self,
6102 encoder_: &mut ___E,
6103 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileAllocateRequest>,
6104 _: (),
6105 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6106 ::fidl_next::munge! {
6107 let crate::wire::FileAllocateRequest {
6108 offset,
6109 length,
6110 mode,
6111
6112 } = out_;
6113 }
6114
6115 ::fidl_next::Encode::encode(&self.offset, encoder_, offset, ())?;
6116
6117 ::fidl_next::Encode::encode(&self.length, encoder_, length, ())?;
6118
6119 ::fidl_next::Encode::encode(&self.mode, encoder_, mode, ())?;
6120
6121 Ok(())
6122 }
6123 }
6124
6125 pub struct FileEnableVerityRequest<T0> {
6127 pub options: T0,
6128 }
6129
6130 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
6131 for FileEnableVerityRequest<T0>
6132 where
6133 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6134 ___E: ::fidl_next::Encoder,
6135 ___E: ::fidl_next::fuchsia::HandleEncoder,
6136 T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
6137 {
6138 #[inline]
6139 fn encode(
6140 self,
6141 encoder_: &mut ___E,
6142 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
6143 _: (),
6144 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6145 ::fidl_next::munge! {
6146 let crate::wire::FileEnableVerityRequest {
6147 options,
6148
6149 } = out_;
6150 }
6151
6152 ::fidl_next::Encode::encode(self.options, encoder_, options, ())?;
6153
6154 Ok(())
6155 }
6156 }
6157
6158 unsafe impl<'a, ___E, T0>
6159 ::fidl_next::Encode<crate::wire::FileEnableVerityRequest<'static>, ___E>
6160 for &'a FileEnableVerityRequest<T0>
6161 where
6162 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6163 ___E: ::fidl_next::Encoder,
6164 ___E: ::fidl_next::fuchsia::HandleEncoder,
6165 &'a T0: ::fidl_next::Encode<crate::wire::VerificationOptions<'static>, ___E>,
6166 {
6167 #[inline]
6168 fn encode(
6169 self,
6170 encoder_: &mut ___E,
6171 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileEnableVerityRequest<'static>>,
6172 _: (),
6173 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6174 ::fidl_next::munge! {
6175 let crate::wire::FileEnableVerityRequest {
6176 options,
6177
6178 } = out_;
6179 }
6180
6181 ::fidl_next::Encode::encode(&self.options, encoder_, options, ())?;
6182
6183 Ok(())
6184 }
6185 }
6186
6187 pub struct FileObject<T0, T1> {
6189 pub event: T0,
6190
6191 pub stream: T1,
6192 }
6193
6194 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E> for FileObject<T0, T1>
6195 where
6196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6197 ___E: ::fidl_next::fuchsia::HandleEncoder,
6198 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>,
6199 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalStream, ___E>,
6200 {
6201 #[inline]
6202 fn encode(
6203 self,
6204 encoder_: &mut ___E,
6205 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
6206 _: (),
6207 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6208 ::fidl_next::munge! {
6209 let crate::wire::FileObject {
6210 event,
6211 stream,
6212
6213 } = out_;
6214 }
6215
6216 ::fidl_next::Encode::encode(self.event, encoder_, event, ())?;
6217
6218 ::fidl_next::Encode::encode(self.stream, encoder_, stream, ())?;
6219
6220 Ok(())
6221 }
6222 }
6223
6224 unsafe impl<'a, ___E, T0, T1> ::fidl_next::Encode<crate::wire::FileObject, ___E>
6225 for &'a FileObject<T0, T1>
6226 where
6227 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6228 ___E: ::fidl_next::fuchsia::HandleEncoder,
6229 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEvent, ___E>,
6230 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalStream, ___E>,
6231 {
6232 #[inline]
6233 fn encode(
6234 self,
6235 encoder_: &mut ___E,
6236 out_: &mut ::core::mem::MaybeUninit<crate::wire::FileObject>,
6237 _: (),
6238 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6239 ::fidl_next::munge! {
6240 let crate::wire::FileObject {
6241 event,
6242 stream,
6243
6244 } = out_;
6245 }
6246
6247 ::fidl_next::Encode::encode(&self.event, encoder_, event, ())?;
6248
6249 ::fidl_next::Encode::encode(&self.stream, encoder_, stream, ())?;
6250
6251 Ok(())
6252 }
6253 }
6254}
6255
6256pub use self::natural::*;
6257
6258#[doc = " Openable defines a node which is capable of opening other objects.\n"]
6260#[derive(PartialEq, Debug)]
6261pub struct Openable;
6262
6263#[cfg(target_os = "fuchsia")]
6264impl ::fidl_next::HasTransport for Openable {
6265 type Transport = ::fidl_next::fuchsia::zx::Channel;
6266}
6267
6268pub mod openable {
6269 pub mod prelude {
6270 pub use crate::{
6271 Openable, OpenableClientHandler, OpenableLocalClientHandler,
6272 OpenableLocalServerHandler, OpenableServerHandler, openable,
6273 };
6274
6275 pub use crate::natural::OpenableOpenRequest;
6276 }
6277
6278 pub struct Open;
6279
6280 impl ::fidl_next::Method for Open {
6281 const ORDINAL: u64 = 6236883748953765593;
6282 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6283 ::fidl_next::protocol::Flexibility::Flexible;
6284
6285 type Protocol = crate::Openable;
6286
6287 type Request = crate::wire::OpenableOpenRequest<'static>;
6288 }
6289
6290 mod ___detail {
6291 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Openable
6292 where
6293 ___T: ::fidl_next::Transport,
6294 {
6295 type Client = OpenableClient<___T>;
6296 type Server = OpenableServer<___T>;
6297 }
6298
6299 #[repr(transparent)]
6301 pub struct OpenableClient<___T: ::fidl_next::Transport> {
6302 #[allow(dead_code)]
6303 client: ::fidl_next::protocol::Client<___T>,
6304 }
6305
6306 impl<___T> OpenableClient<___T>
6307 where
6308 ___T: ::fidl_next::Transport,
6309 {
6310 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
6311 pub fn open(
6312 &self,
6313
6314 path: impl ::fidl_next::Encode<
6315 ::fidl_next::wire::String<'static>,
6316 <___T as ::fidl_next::Transport>::SendBuffer,
6317 >,
6318
6319 flags: impl ::fidl_next::Encode<
6320 crate::wire::Flags,
6321 <___T as ::fidl_next::Transport>::SendBuffer,
6322 >,
6323
6324 options: impl ::fidl_next::Encode<
6325 crate::wire::Options<'static>,
6326 <___T as ::fidl_next::Transport>::SendBuffer,
6327 >,
6328
6329 object: impl ::fidl_next::Encode<
6330 ::fidl_next::wire::fuchsia::Channel,
6331 <___T as ::fidl_next::Transport>::SendBuffer,
6332 >,
6333 ) -> ::fidl_next::SendFuture<'_, ___T>
6334 where
6335 <___T as ::fidl_next::Transport>::SendBuffer:
6336 ::fidl_next::encoder::InternalHandleEncoder,
6337 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
6338 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
6339 {
6340 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
6341 }
6342
6343 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
6344 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
6345 where
6346 ___R: ::fidl_next::Encode<
6347 crate::wire::OpenableOpenRequest<'static>,
6348 <___T as ::fidl_next::Transport>::SendBuffer,
6349 >,
6350 {
6351 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
6352 6236883748953765593,
6353 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
6354 request,
6355 ))
6356 }
6357 }
6358
6359 #[repr(transparent)]
6361 pub struct OpenableServer<___T: ::fidl_next::Transport> {
6362 server: ::fidl_next::protocol::Server<___T>,
6363 }
6364
6365 impl<___T> OpenableServer<___T> where ___T: ::fidl_next::Transport {}
6366 }
6367}
6368
6369#[diagnostic::on_unimplemented(
6370 note = "If {Self} implements the non-local OpenableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
6371)]
6372
6373pub trait OpenableLocalClientHandler<
6377 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6378 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6379>
6380{
6381 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
6382 ::core::future::ready(())
6383 }
6384}
6385
6386impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Openable
6387where
6388 ___H: OpenableLocalClientHandler<___T>,
6389 ___T: ::fidl_next::Transport,
6390{
6391 async fn on_event(
6392 handler: &mut ___H,
6393 mut message: ::fidl_next::Message<___T>,
6394 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6395 match *message.header().ordinal {
6396 ordinal => {
6397 handler.on_unknown_interaction(ordinal).await;
6398 if ::core::matches!(
6399 message.header().flexibility(),
6400 ::fidl_next::protocol::Flexibility::Strict
6401 ) {
6402 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6403 } else {
6404 Ok(())
6405 }
6406 }
6407 }
6408 }
6409}
6410
6411#[diagnostic::on_unimplemented(
6412 note = "If {Self} implements the non-local OpenableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
6413)]
6414
6415pub trait OpenableLocalServerHandler<
6419 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6420 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6421>
6422{
6423 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
6424 fn open(
6425 &mut self,
6426
6427 request: ::fidl_next::Request<openable::Open, ___T>,
6428 ) -> impl ::core::future::Future<Output = ()>;
6429
6430 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
6431 ::core::future::ready(())
6432 }
6433}
6434
6435impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Openable
6436where
6437 ___H: OpenableLocalServerHandler<___T>,
6438 ___T: ::fidl_next::Transport,
6439 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
6440 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
6441 Constraint = (),
6442 >,
6443{
6444 async fn on_one_way(
6445 handler: &mut ___H,
6446 mut message: ::fidl_next::Message<___T>,
6447 ) -> ::core::result::Result<
6448 (),
6449 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6450 > {
6451 match *message.header().ordinal {
6452 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
6453 Ok(decoded) => {
6454 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
6455 Ok(())
6456 }
6457 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6458 ordinal: 6236883748953765593,
6459 error,
6460 }),
6461 },
6462
6463 ordinal => {
6464 handler.on_unknown_interaction(ordinal).await;
6465 if ::core::matches!(
6466 message.header().flexibility(),
6467 ::fidl_next::protocol::Flexibility::Strict
6468 ) {
6469 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6470 } else {
6471 Ok(())
6472 }
6473 }
6474 }
6475 }
6476
6477 async fn on_two_way(
6478 handler: &mut ___H,
6479 mut message: ::fidl_next::Message<___T>,
6480 responder: ::fidl_next::protocol::Responder<___T>,
6481 ) -> ::core::result::Result<
6482 (),
6483 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6484 > {
6485 match *message.header().ordinal {
6486 ordinal => {
6487 handler.on_unknown_interaction(ordinal).await;
6488 if ::core::matches!(
6489 message.header().flexibility(),
6490 ::fidl_next::protocol::Flexibility::Strict
6491 ) {
6492 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6493 } else {
6494 responder
6495 .respond_framework_error(
6496 ordinal,
6497 ::fidl_next::FrameworkError::UnknownMethod,
6498 )
6499 .expect("encoding a framework error should never fail")
6500 .await?;
6501 Ok(())
6502 }
6503 }
6504 }
6505 }
6506}
6507
6508pub trait OpenableClientHandler<
6512 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6513 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6514>
6515{
6516 fn on_unknown_interaction(
6517 &mut self,
6518 ordinal: u64,
6519 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6520 ::core::future::ready(())
6521 }
6522}
6523
6524impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Openable
6525where
6526 ___H: OpenableClientHandler<___T> + ::core::marker::Send,
6527 ___T: ::fidl_next::Transport,
6528{
6529 async fn on_event(
6530 handler: &mut ___H,
6531 mut message: ::fidl_next::Message<___T>,
6532 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6533 match *message.header().ordinal {
6534 ordinal => {
6535 handler.on_unknown_interaction(ordinal).await;
6536 if ::core::matches!(
6537 message.header().flexibility(),
6538 ::fidl_next::protocol::Flexibility::Strict
6539 ) {
6540 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6541 } else {
6542 Ok(())
6543 }
6544 }
6545 }
6546 }
6547}
6548
6549pub trait OpenableServerHandler<
6553 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6554 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6555>
6556{
6557 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
6558 fn open(
6559 &mut self,
6560
6561 request: ::fidl_next::Request<openable::Open, ___T>,
6562 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6563
6564 fn on_unknown_interaction(
6565 &mut self,
6566 ordinal: u64,
6567 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
6568 ::core::future::ready(())
6569 }
6570}
6571
6572impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Openable
6573where
6574 ___H: OpenableServerHandler<___T> + ::core::marker::Send,
6575 ___T: ::fidl_next::Transport,
6576 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
6577 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
6578 Constraint = (),
6579 >,
6580{
6581 async fn on_one_way(
6582 handler: &mut ___H,
6583 mut message: ::fidl_next::Message<___T>,
6584 ) -> ::core::result::Result<
6585 (),
6586 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6587 > {
6588 match *message.header().ordinal {
6589 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
6590 Ok(decoded) => {
6591 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
6592 Ok(())
6593 }
6594 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
6595 ordinal: 6236883748953765593,
6596 error,
6597 }),
6598 },
6599
6600 ordinal => {
6601 handler.on_unknown_interaction(ordinal).await;
6602 if ::core::matches!(
6603 message.header().flexibility(),
6604 ::fidl_next::protocol::Flexibility::Strict
6605 ) {
6606 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6607 } else {
6608 Ok(())
6609 }
6610 }
6611 }
6612 }
6613
6614 async fn on_two_way(
6615 handler: &mut ___H,
6616 mut message: ::fidl_next::Message<___T>,
6617 responder: ::fidl_next::protocol::Responder<___T>,
6618 ) -> ::core::result::Result<
6619 (),
6620 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6621 > {
6622 match *message.header().ordinal {
6623 ordinal => {
6624 handler.on_unknown_interaction(ordinal).await;
6625 if ::core::matches!(
6626 message.header().flexibility(),
6627 ::fidl_next::protocol::Flexibility::Strict
6628 ) {
6629 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
6630 } else {
6631 responder
6632 .respond_framework_error(
6633 ordinal,
6634 ::fidl_next::FrameworkError::UnknownMethod,
6635 )
6636 .expect("encoding a framework error should never fail")
6637 .await?;
6638 Ok(())
6639 }
6640 }
6641 }
6642 }
6643}
6644
6645impl<___T> OpenableClientHandler<___T> for ::fidl_next::IgnoreEvents
6646where
6647 ___T: ::fidl_next::Transport,
6648{
6649 async fn on_unknown_interaction(&mut self, _: u64) {}
6650}
6651
6652impl<___H, ___T> OpenableLocalClientHandler<___T> for ::fidl_next::Local<___H>
6653where
6654 ___H: OpenableClientHandler<___T>,
6655 ___T: ::fidl_next::Transport,
6656{
6657 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6658 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6659 }
6660}
6661
6662impl<___H, ___T> OpenableLocalServerHandler<___T> for ::fidl_next::Local<___H>
6663where
6664 ___H: OpenableServerHandler<___T>,
6665 ___T: ::fidl_next::Transport,
6666{
6667 async fn open(&mut self, request: ::fidl_next::Request<openable::Open, ___T>) {
6668 ___H::open(&mut self.0, request).await
6669 }
6670
6671 async fn on_unknown_interaction(&mut self, ordinal: u64) {
6672 ___H::on_unknown_interaction(&mut self.0, ordinal).await
6673 }
6674}
6675
6676#[doc = " Node defines the minimal interface for entities which can be accessed in a filesystem.\n"]
6678#[derive(PartialEq, Debug)]
6679pub struct Node;
6680
6681impl ::fidl_next::Discoverable for Node {
6682 const PROTOCOL_NAME: &'static str = "fuchsia.io.Node";
6683}
6684
6685#[cfg(target_os = "fuchsia")]
6686impl ::fidl_next::HasTransport for Node {
6687 type Transport = ::fidl_next::fuchsia::zx::Channel;
6688}
6689
6690pub mod node {
6691 pub mod prelude {
6692 pub use crate::{
6693 Node, NodeClientHandler, NodeLocalClientHandler, NodeLocalServerHandler,
6694 NodeServerHandler, node,
6695 };
6696
6697 pub use crate::natural::ExtendedAttributeValue;
6698
6699 pub use crate::natural::MutableNodeAttributes;
6700
6701 pub use crate::natural::NodeAttributes2;
6702
6703 pub use crate::natural::NodeDeprecatedGetAttrResponse;
6704
6705 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
6706
6707 pub use crate::natural::NodeDeprecatedSetAttrRequest;
6708
6709 pub use crate::natural::NodeDeprecatedSetAttrResponse;
6710
6711 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
6712
6713 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
6714
6715 pub use crate::natural::NodeGetAttributesRequest;
6716
6717 pub use crate::natural::NodeGetExtendedAttributeRequest;
6718
6719 pub use crate::natural::NodeListExtendedAttributesRequest;
6720
6721 pub use crate::natural::NodeOnOpenRequest;
6722
6723 pub use crate::natural::NodeQueryFilesystemResponse;
6724
6725 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
6726
6727 pub use crate::natural::NodeSetExtendedAttributeRequest;
6728
6729 pub use crate::natural::NodeSetFlagsRequest;
6730
6731 pub use crate::natural::NodeGetFlagsResponse;
6732
6733 pub use crate::natural::NodeGetTokenResponse;
6734
6735 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
6736
6737 pub use crate::natural::NodeSetExtendedAttributeResponse;
6738
6739 pub use crate::natural::NodeSetFlagsResponse;
6740
6741 pub use crate::natural::NodeSyncResponse;
6742
6743 pub use crate::natural::NodeUpdateAttributesResponse;
6744
6745 pub use crate::natural::Representation;
6746
6747 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
6748
6749 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
6750
6751 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
6752 }
6753
6754 pub struct Clone;
6755
6756 impl ::fidl_next::Method for Clone {
6757 const ORDINAL: u64 = 2366825959783828089;
6758 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6759 ::fidl_next::protocol::Flexibility::Strict;
6760
6761 type Protocol = crate::Node;
6762
6763 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
6764 }
6765
6766 pub struct Close;
6767
6768 impl ::fidl_next::Method for Close {
6769 const ORDINAL: u64 = 6540867515453498750;
6770 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6771 ::fidl_next::protocol::Flexibility::Strict;
6772
6773 type Protocol = crate::Node;
6774
6775 type Request = ::fidl_next::wire::EmptyMessageBody;
6776 }
6777
6778 impl ::fidl_next::TwoWayMethod for Close {
6779 type Response = ::fidl_next::wire::Result<
6780 'static,
6781 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
6782 ::fidl_next::wire::Int32,
6783 >;
6784 }
6785
6786 impl<___R> ::fidl_next::Respond<___R> for Close {
6787 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
6788
6789 fn respond(response: ___R) -> Self::Output {
6790 ::core::result::Result::Ok(response)
6791 }
6792 }
6793
6794 impl<___R> ::fidl_next::RespondErr<___R> for Close {
6795 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
6796
6797 fn respond_err(response: ___R) -> Self::Output {
6798 ::core::result::Result::Err(response)
6799 }
6800 }
6801
6802 pub struct Query;
6803
6804 impl ::fidl_next::Method for Query {
6805 const ORDINAL: u64 = 2763219980499352582;
6806 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6807 ::fidl_next::protocol::Flexibility::Strict;
6808
6809 type Protocol = crate::Node;
6810
6811 type Request = ::fidl_next::wire::EmptyMessageBody;
6812 }
6813
6814 impl ::fidl_next::TwoWayMethod for Query {
6815 type Response = ::fidl_next::wire::Strict<
6816 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
6817 >;
6818 }
6819
6820 impl<___R> ::fidl_next::Respond<___R> for Query {
6821 type Output =
6822 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
6823
6824 fn respond(response: ___R) -> Self::Output {
6825 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
6826 protocol: response,
6827 })
6828 }
6829 }
6830
6831 pub struct OnOpen;
6832
6833 impl ::fidl_next::Method for OnOpen {
6834 const ORDINAL: u64 = 9207534335756671346;
6835 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6836 ::fidl_next::protocol::Flexibility::Flexible;
6837
6838 type Protocol = crate::Node;
6839
6840 type Request = crate::wire::NodeOnOpenRequest<'static>;
6841 }
6842
6843 pub struct DeprecatedGetAttr;
6844
6845 impl ::fidl_next::Method for DeprecatedGetAttr {
6846 const ORDINAL: u64 = 8689798978500614909;
6847 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6848 ::fidl_next::protocol::Flexibility::Strict;
6849
6850 type Protocol = crate::Node;
6851
6852 type Request = ::fidl_next::wire::EmptyMessageBody;
6853 }
6854
6855 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
6856 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
6857 }
6858
6859 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
6860 type Output = ::fidl_next::Strict<___R>;
6861
6862 fn respond(response: ___R) -> Self::Output {
6863 ::fidl_next::Strict(response)
6864 }
6865 }
6866
6867 pub struct DeprecatedSetAttr;
6868
6869 impl ::fidl_next::Method for DeprecatedSetAttr {
6870 const ORDINAL: u64 = 4721673413776871238;
6871 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6872 ::fidl_next::protocol::Flexibility::Strict;
6873
6874 type Protocol = crate::Node;
6875
6876 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
6877 }
6878
6879 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
6880 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
6881 }
6882
6883 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
6884 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
6885
6886 fn respond(response: ___R) -> Self::Output {
6887 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
6888 }
6889 }
6890
6891 pub struct DeprecatedGetFlags;
6892
6893 impl ::fidl_next::Method for DeprecatedGetFlags {
6894 const ORDINAL: u64 = 6595803110182632097;
6895 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6896 ::fidl_next::protocol::Flexibility::Strict;
6897
6898 type Protocol = crate::Node;
6899
6900 type Request = ::fidl_next::wire::EmptyMessageBody;
6901 }
6902
6903 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
6904 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
6905 }
6906
6907 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
6908 type Output = ::fidl_next::Strict<___R>;
6909
6910 fn respond(response: ___R) -> Self::Output {
6911 ::fidl_next::Strict(response)
6912 }
6913 }
6914
6915 pub struct DeprecatedSetFlags;
6916
6917 impl ::fidl_next::Method for DeprecatedSetFlags {
6918 const ORDINAL: u64 = 5950864159036794675;
6919 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6920 ::fidl_next::protocol::Flexibility::Strict;
6921
6922 type Protocol = crate::Node;
6923
6924 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
6925 }
6926
6927 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
6928 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
6929 }
6930
6931 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
6932 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
6933
6934 fn respond(response: ___R) -> Self::Output {
6935 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
6936 }
6937 }
6938
6939 pub struct GetFlags;
6940
6941 impl ::fidl_next::Method for GetFlags {
6942 const ORDINAL: u64 = 105530239381466147;
6943 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6944 ::fidl_next::protocol::Flexibility::Flexible;
6945
6946 type Protocol = crate::Node;
6947
6948 type Request = ::fidl_next::wire::EmptyMessageBody;
6949 }
6950
6951 impl ::fidl_next::TwoWayMethod for GetFlags {
6952 type Response = ::fidl_next::wire::Result<
6953 'static,
6954 crate::wire::NodeGetFlagsResponse,
6955 ::fidl_next::wire::fuchsia::Status,
6956 >;
6957 }
6958
6959 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
6960 type Output = ::core::result::Result<
6961 crate::generic::NodeGetFlagsResponse<___R>,
6962 ::fidl_next::never::Never,
6963 >;
6964
6965 fn respond(response: ___R) -> Self::Output {
6966 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
6967 }
6968 }
6969
6970 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
6971 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
6972
6973 fn respond_err(response: ___R) -> Self::Output {
6974 ::core::result::Result::Err(response)
6975 }
6976 }
6977
6978 pub struct SetFlags;
6979
6980 impl ::fidl_next::Method for SetFlags {
6981 const ORDINAL: u64 = 6172186066099445416;
6982 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
6983 ::fidl_next::protocol::Flexibility::Flexible;
6984
6985 type Protocol = crate::Node;
6986
6987 type Request = crate::wire::NodeSetFlagsRequest;
6988 }
6989
6990 impl ::fidl_next::TwoWayMethod for SetFlags {
6991 type Response = ::fidl_next::wire::Result<
6992 'static,
6993 crate::wire::NodeSetFlagsResponse,
6994 ::fidl_next::wire::fuchsia::Status,
6995 >;
6996 }
6997
6998 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
6999 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7000
7001 fn respond(response: ___R) -> Self::Output {
7002 ::core::result::Result::Ok(response)
7003 }
7004 }
7005
7006 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
7007 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7008
7009 fn respond_err(response: ___R) -> Self::Output {
7010 ::core::result::Result::Err(response)
7011 }
7012 }
7013
7014 pub struct QueryFilesystem;
7015
7016 impl ::fidl_next::Method for QueryFilesystem {
7017 const ORDINAL: u64 = 8013111122914313744;
7018 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7019 ::fidl_next::protocol::Flexibility::Strict;
7020
7021 type Protocol = crate::Node;
7022
7023 type Request = ::fidl_next::wire::EmptyMessageBody;
7024 }
7025
7026 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
7027 type Response =
7028 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
7029 }
7030
7031 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
7032 type Output = ::fidl_next::Strict<___R>;
7033
7034 fn respond(response: ___R) -> Self::Output {
7035 ::fidl_next::Strict(response)
7036 }
7037 }
7038
7039 pub struct OnRepresentation;
7040
7041 impl ::fidl_next::Method for OnRepresentation {
7042 const ORDINAL: u64 = 6679970090861613324;
7043 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7044 ::fidl_next::protocol::Flexibility::Strict;
7045
7046 type Protocol = crate::Node;
7047
7048 type Request = crate::wire::Representation<'static>;
7049 }
7050
7051 pub struct GetToken;
7052
7053 impl ::fidl_next::Method for GetToken {
7054 const ORDINAL: u64 = 5788516050773961964;
7055 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7056 ::fidl_next::protocol::Flexibility::Flexible;
7057
7058 type Protocol = crate::Node;
7059
7060 type Request = ::fidl_next::wire::EmptyMessageBody;
7061 }
7062
7063 impl ::fidl_next::TwoWayMethod for GetToken {
7064 type Response = ::fidl_next::wire::Result<
7065 'static,
7066 crate::wire::NodeGetTokenResponse,
7067 ::fidl_next::wire::fuchsia::Status,
7068 >;
7069 }
7070
7071 impl<___R> ::fidl_next::Respond<___R> for GetToken {
7072 type Output = ::core::result::Result<
7073 crate::generic::NodeGetTokenResponse<___R>,
7074 ::fidl_next::never::Never,
7075 >;
7076
7077 fn respond(response: ___R) -> Self::Output {
7078 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
7079 }
7080 }
7081
7082 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
7083 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7084
7085 fn respond_err(response: ___R) -> Self::Output {
7086 ::core::result::Result::Err(response)
7087 }
7088 }
7089
7090 pub struct GetAttributes;
7091
7092 impl ::fidl_next::Method for GetAttributes {
7093 const ORDINAL: u64 = 4414537700416816443;
7094 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7095 ::fidl_next::protocol::Flexibility::Strict;
7096
7097 type Protocol = crate::Node;
7098
7099 type Request = crate::wire::NodeGetAttributesRequest;
7100 }
7101
7102 impl ::fidl_next::TwoWayMethod for GetAttributes {
7103 type Response = ::fidl_next::wire::Result<
7104 'static,
7105 crate::wire::NodeAttributes2<'static>,
7106 ::fidl_next::wire::fuchsia::Status,
7107 >;
7108 }
7109
7110 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
7111 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7112
7113 fn respond(response: ___R) -> Self::Output {
7114 ::core::result::Result::Ok(response)
7115 }
7116 }
7117
7118 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
7119 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7120
7121 fn respond_err(response: ___R) -> Self::Output {
7122 ::core::result::Result::Err(response)
7123 }
7124 }
7125
7126 pub struct UpdateAttributes;
7127
7128 impl ::fidl_next::Method for UpdateAttributes {
7129 const ORDINAL: u64 = 3677402239314018056;
7130 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7131 ::fidl_next::protocol::Flexibility::Strict;
7132
7133 type Protocol = crate::Node;
7134
7135 type Request = crate::wire::MutableNodeAttributes<'static>;
7136 }
7137
7138 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
7139 type Response = ::fidl_next::wire::Result<
7140 'static,
7141 crate::wire::NodeUpdateAttributesResponse,
7142 ::fidl_next::wire::fuchsia::Status,
7143 >;
7144 }
7145
7146 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
7147 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7148
7149 fn respond(response: ___R) -> Self::Output {
7150 ::core::result::Result::Ok(response)
7151 }
7152 }
7153
7154 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
7155 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7156
7157 fn respond_err(response: ___R) -> Self::Output {
7158 ::core::result::Result::Err(response)
7159 }
7160 }
7161
7162 pub struct Sync;
7163
7164 impl ::fidl_next::Method for Sync {
7165 const ORDINAL: u64 = 3196473584242777161;
7166 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7167 ::fidl_next::protocol::Flexibility::Strict;
7168
7169 type Protocol = crate::Node;
7170
7171 type Request = ::fidl_next::wire::EmptyMessageBody;
7172 }
7173
7174 impl ::fidl_next::TwoWayMethod for Sync {
7175 type Response = ::fidl_next::wire::Result<
7176 'static,
7177 crate::wire::NodeSyncResponse,
7178 ::fidl_next::wire::fuchsia::Status,
7179 >;
7180 }
7181
7182 impl<___R> ::fidl_next::Respond<___R> for Sync {
7183 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7184
7185 fn respond(response: ___R) -> Self::Output {
7186 ::core::result::Result::Ok(response)
7187 }
7188 }
7189
7190 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
7191 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7192
7193 fn respond_err(response: ___R) -> Self::Output {
7194 ::core::result::Result::Err(response)
7195 }
7196 }
7197
7198 pub struct ListExtendedAttributes;
7199
7200 impl ::fidl_next::Method for ListExtendedAttributes {
7201 const ORDINAL: u64 = 5431626189872037072;
7202 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7203 ::fidl_next::protocol::Flexibility::Strict;
7204
7205 type Protocol = crate::Node;
7206
7207 type Request = crate::wire::NodeListExtendedAttributesRequest;
7208 }
7209
7210 pub struct GetExtendedAttribute;
7211
7212 impl ::fidl_next::Method for GetExtendedAttribute {
7213 const ORDINAL: u64 = 5043930208506967771;
7214 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7215 ::fidl_next::protocol::Flexibility::Strict;
7216
7217 type Protocol = crate::Node;
7218
7219 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
7220 }
7221
7222 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
7223 type Response = ::fidl_next::wire::Result<
7224 'static,
7225 crate::wire::ExtendedAttributeValue<'static>,
7226 ::fidl_next::wire::fuchsia::Status,
7227 >;
7228 }
7229
7230 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
7231 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7232
7233 fn respond(response: ___R) -> Self::Output {
7234 ::core::result::Result::Ok(response)
7235 }
7236 }
7237
7238 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
7239 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7240
7241 fn respond_err(response: ___R) -> Self::Output {
7242 ::core::result::Result::Err(response)
7243 }
7244 }
7245
7246 pub struct SetExtendedAttribute;
7247
7248 impl ::fidl_next::Method for SetExtendedAttribute {
7249 const ORDINAL: u64 = 5374223046099989052;
7250 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7251 ::fidl_next::protocol::Flexibility::Strict;
7252
7253 type Protocol = crate::Node;
7254
7255 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
7256 }
7257
7258 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
7259 type Response = ::fidl_next::wire::Result<
7260 'static,
7261 crate::wire::NodeSetExtendedAttributeResponse,
7262 ::fidl_next::wire::fuchsia::Status,
7263 >;
7264 }
7265
7266 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
7267 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7268
7269 fn respond(response: ___R) -> Self::Output {
7270 ::core::result::Result::Ok(response)
7271 }
7272 }
7273
7274 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
7275 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7276
7277 fn respond_err(response: ___R) -> Self::Output {
7278 ::core::result::Result::Err(response)
7279 }
7280 }
7281
7282 pub struct RemoveExtendedAttribute;
7283
7284 impl ::fidl_next::Method for RemoveExtendedAttribute {
7285 const ORDINAL: u64 = 8794297771444732717;
7286 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7287 ::fidl_next::protocol::Flexibility::Strict;
7288
7289 type Protocol = crate::Node;
7290
7291 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
7292 }
7293
7294 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
7295 type Response = ::fidl_next::wire::Result<
7296 'static,
7297 crate::wire::NodeRemoveExtendedAttributeResponse,
7298 ::fidl_next::wire::fuchsia::Status,
7299 >;
7300 }
7301
7302 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
7303 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7304
7305 fn respond(response: ___R) -> Self::Output {
7306 ::core::result::Result::Ok(response)
7307 }
7308 }
7309
7310 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
7311 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7312
7313 fn respond_err(response: ___R) -> Self::Output {
7314 ::core::result::Result::Err(response)
7315 }
7316 }
7317
7318 mod ___detail {
7319 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Node
7320 where
7321 ___T: ::fidl_next::Transport,
7322 {
7323 type Client = NodeClient<___T>;
7324 type Server = NodeServer<___T>;
7325 }
7326
7327 #[repr(transparent)]
7329 pub struct NodeClient<___T: ::fidl_next::Transport> {
7330 #[allow(dead_code)]
7331 client: ::fidl_next::protocol::Client<___T>,
7332 }
7333
7334 impl<___T> NodeClient<___T>
7335 where
7336 ___T: ::fidl_next::Transport,
7337 {
7338 pub fn clone(
7339 &self,
7340
7341 request: impl ::fidl_next::Encode<
7342 ::fidl_next::ServerEnd<
7343 ::fidl_next_fuchsia_unknown::Cloneable,
7344 ::fidl_next::wire::fuchsia::Channel,
7345 >,
7346 <___T as ::fidl_next::Transport>::SendBuffer,
7347 >,
7348 ) -> ::fidl_next::SendFuture<'_, ___T>
7349 where
7350 <___T as ::fidl_next::Transport>::SendBuffer:
7351 ::fidl_next::encoder::InternalHandleEncoder,
7352 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7353 {
7354 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
7355 request,
7356 })
7357 }
7358
7359 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7360 where
7361 ___R: ::fidl_next::Encode<
7362 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
7363 <___T as ::fidl_next::Transport>::SendBuffer,
7364 >,
7365 {
7366 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7367 2366825959783828089,
7368 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
7369 request,
7370 ))
7371 }
7372
7373 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
7374 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
7375 ::fidl_next::TwoWayFuture::from_untyped(
7376 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7377 6540867515453498750,
7378 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
7379 (),
7380 ),
7381 )
7382 }
7383
7384 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
7385 ::fidl_next::TwoWayFuture::from_untyped(
7386 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7387 2763219980499352582,
7388 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
7389 (),
7390 ),
7391 )
7392 }
7393
7394 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
7395 pub fn deprecated_get_attr(
7396 &self,
7397 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
7398 ::fidl_next::TwoWayFuture::from_untyped(
7399 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7400 8689798978500614909,
7401 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
7402 (),
7403 ),
7404 )
7405 }
7406
7407 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7408 pub fn deprecated_set_attr(
7409 &self,
7410
7411 flags: impl ::fidl_next::Encode<
7412 crate::wire::NodeAttributeFlags,
7413 <___T as ::fidl_next::Transport>::SendBuffer,
7414 >,
7415
7416 attributes: impl ::fidl_next::Encode<
7417 crate::wire::NodeAttributes,
7418 <___T as ::fidl_next::Transport>::SendBuffer,
7419 >,
7420 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
7421 where
7422 <___T as ::fidl_next::Transport>::SendBuffer:
7423 ::fidl_next::encoder::InternalHandleEncoder,
7424 {
7425 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
7426 flags,
7427
7428 attributes,
7429 })
7430 }
7431
7432 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7433 pub fn deprecated_set_attr_with<___R>(
7434 &self,
7435 request: ___R,
7436 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
7437 where
7438 ___R: ::fidl_next::Encode<
7439 crate::wire::NodeDeprecatedSetAttrRequest,
7440 <___T as ::fidl_next::Transport>::SendBuffer,
7441 >,
7442 {
7443 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7444 4721673413776871238,
7445 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
7446 request,
7447 ))
7448 }
7449
7450 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
7451 pub fn deprecated_get_flags(
7452 &self,
7453 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
7454 ::fidl_next::TwoWayFuture::from_untyped(
7455 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7456 6595803110182632097,
7457 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
7458 (),
7459 ),
7460 )
7461 }
7462
7463 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7464 pub fn deprecated_set_flags(
7465 &self,
7466
7467 flags: impl ::fidl_next::Encode<
7468 crate::wire::OpenFlags,
7469 <___T as ::fidl_next::Transport>::SendBuffer,
7470 >,
7471 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
7472 where
7473 <___T as ::fidl_next::Transport>::SendBuffer:
7474 ::fidl_next::encoder::InternalHandleEncoder,
7475 {
7476 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
7477 flags,
7478 })
7479 }
7480
7481 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
7482 pub fn deprecated_set_flags_with<___R>(
7483 &self,
7484 request: ___R,
7485 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
7486 where
7487 ___R: ::fidl_next::Encode<
7488 crate::wire::NodeDeprecatedSetFlagsRequest,
7489 <___T as ::fidl_next::Transport>::SendBuffer,
7490 >,
7491 {
7492 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7493 5950864159036794675,
7494 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
7495 request,
7496 ))
7497 }
7498
7499 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
7500 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
7501 ::fidl_next::TwoWayFuture::from_untyped(
7502 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7503 105530239381466147,
7504 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
7505 (),
7506 ),
7507 )
7508 }
7509
7510 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
7511 pub fn set_flags(
7512 &self,
7513
7514 flags: impl ::fidl_next::Encode<
7515 crate::wire::Flags,
7516 <___T as ::fidl_next::Transport>::SendBuffer,
7517 >,
7518 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
7519 where
7520 <___T as ::fidl_next::Transport>::SendBuffer:
7521 ::fidl_next::encoder::InternalHandleEncoder,
7522 {
7523 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
7524 }
7525
7526 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
7527 pub fn set_flags_with<___R>(
7528 &self,
7529 request: ___R,
7530 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
7531 where
7532 ___R: ::fidl_next::Encode<
7533 crate::wire::NodeSetFlagsRequest,
7534 <___T as ::fidl_next::Transport>::SendBuffer,
7535 >,
7536 {
7537 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7538 6172186066099445416,
7539 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
7540 request,
7541 ))
7542 }
7543
7544 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
7545 pub fn query_filesystem(
7546 &self,
7547 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
7548 ::fidl_next::TwoWayFuture::from_untyped(
7549 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7550 8013111122914313744,
7551 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
7552 (),
7553 ),
7554 )
7555 }
7556
7557 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
7558 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
7559 ::fidl_next::TwoWayFuture::from_untyped(
7560 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7561 5788516050773961964,
7562 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
7563 (),
7564 ),
7565 )
7566 }
7567
7568 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
7569 pub fn get_attributes(
7570 &self,
7571
7572 query: impl ::fidl_next::Encode<
7573 crate::wire::NodeAttributesQuery,
7574 <___T as ::fidl_next::Transport>::SendBuffer,
7575 >,
7576 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
7577 where
7578 <___T as ::fidl_next::Transport>::SendBuffer:
7579 ::fidl_next::encoder::InternalHandleEncoder,
7580 {
7581 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
7582 }
7583
7584 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
7585 pub fn get_attributes_with<___R>(
7586 &self,
7587 request: ___R,
7588 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
7589 where
7590 ___R: ::fidl_next::Encode<
7591 crate::wire::NodeGetAttributesRequest,
7592 <___T as ::fidl_next::Transport>::SendBuffer,
7593 >,
7594 {
7595 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7596 4414537700416816443,
7597 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
7598 request,
7599 ))
7600 }
7601
7602 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
7603 pub fn update_attributes_with<___R>(
7604 &self,
7605 request: ___R,
7606 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
7607 where
7608 ___R: ::fidl_next::Encode<
7609 crate::wire::MutableNodeAttributes<'static>,
7610 <___T as ::fidl_next::Transport>::SendBuffer,
7611 >,
7612 {
7613 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7614 3677402239314018056,
7615 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
7616 request,
7617 ))
7618 }
7619
7620 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
7621 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
7622 ::fidl_next::TwoWayFuture::from_untyped(
7623 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
7624 3196473584242777161,
7625 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
7626 (),
7627 ),
7628 )
7629 }
7630
7631 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
7632 pub fn list_extended_attributes(
7633 &self,
7634
7635 iterator: impl ::fidl_next::Encode<
7636 ::fidl_next::ServerEnd<
7637 crate::ExtendedAttributeIterator,
7638 ::fidl_next::wire::fuchsia::Channel,
7639 >,
7640 <___T as ::fidl_next::Transport>::SendBuffer,
7641 >,
7642 ) -> ::fidl_next::SendFuture<'_, ___T>
7643 where
7644 <___T as ::fidl_next::Transport>::SendBuffer:
7645 ::fidl_next::encoder::InternalHandleEncoder,
7646 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7647 {
7648 self.list_extended_attributes_with(
7649 crate::generic::NodeListExtendedAttributesRequest { iterator },
7650 )
7651 }
7652
7653 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
7654 pub fn list_extended_attributes_with<___R>(
7655 &self,
7656 request: ___R,
7657 ) -> ::fidl_next::SendFuture<'_, ___T>
7658 where
7659 ___R: ::fidl_next::Encode<
7660 crate::wire::NodeListExtendedAttributesRequest,
7661 <___T as ::fidl_next::Transport>::SendBuffer,
7662 >,
7663 {
7664 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
7665 5431626189872037072,
7666 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
7667 request,
7668 ))
7669 }
7670
7671 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
7672 pub fn get_extended_attribute(
7673 &self,
7674
7675 name: impl ::fidl_next::Encode<
7676 ::fidl_next::wire::Vector<'static, u8>,
7677 <___T as ::fidl_next::Transport>::SendBuffer,
7678 >,
7679 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7680 where
7681 <___T as ::fidl_next::Transport>::SendBuffer:
7682 ::fidl_next::encoder::InternalHandleEncoder,
7683 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7684 {
7685 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
7686 name,
7687 })
7688 }
7689
7690 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
7691 pub fn get_extended_attribute_with<___R>(
7692 &self,
7693 request: ___R,
7694 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
7695 where
7696 ___R: ::fidl_next::Encode<
7697 crate::wire::NodeGetExtendedAttributeRequest<'static>,
7698 <___T as ::fidl_next::Transport>::SendBuffer,
7699 >,
7700 {
7701 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7702 5043930208506967771,
7703 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7704 request,
7705 ))
7706 }
7707
7708 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
7709 pub fn set_extended_attribute(
7710 &self,
7711
7712 name: impl ::fidl_next::Encode<
7713 ::fidl_next::wire::Vector<'static, u8>,
7714 <___T as ::fidl_next::Transport>::SendBuffer,
7715 >,
7716
7717 value: impl ::fidl_next::Encode<
7718 crate::wire::ExtendedAttributeValue<'static>,
7719 <___T as ::fidl_next::Transport>::SendBuffer,
7720 >,
7721
7722 mode: impl ::fidl_next::Encode<
7723 crate::wire::SetExtendedAttributeMode,
7724 <___T as ::fidl_next::Transport>::SendBuffer,
7725 >,
7726 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7727 where
7728 <___T as ::fidl_next::Transport>::SendBuffer:
7729 ::fidl_next::encoder::InternalHandleEncoder,
7730 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7731 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7732 {
7733 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
7734 name,
7735
7736 value,
7737
7738 mode,
7739 })
7740 }
7741
7742 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
7743 pub fn set_extended_attribute_with<___R>(
7744 &self,
7745 request: ___R,
7746 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
7747 where
7748 ___R: ::fidl_next::Encode<
7749 crate::wire::NodeSetExtendedAttributeRequest<'static>,
7750 <___T as ::fidl_next::Transport>::SendBuffer,
7751 >,
7752 {
7753 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7754 5374223046099989052,
7755 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7756 request,
7757 ))
7758 }
7759
7760 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
7761 pub fn remove_extended_attribute(
7762 &self,
7763
7764 name: impl ::fidl_next::Encode<
7765 ::fidl_next::wire::Vector<'static, u8>,
7766 <___T as ::fidl_next::Transport>::SendBuffer,
7767 >,
7768 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7769 where
7770 <___T as ::fidl_next::Transport>::SendBuffer:
7771 ::fidl_next::encoder::InternalHandleEncoder,
7772 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7773 {
7774 self.remove_extended_attribute_with(
7775 crate::generic::NodeRemoveExtendedAttributeRequest { name },
7776 )
7777 }
7778
7779 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
7780 pub fn remove_extended_attribute_with<___R>(
7781 &self,
7782 request: ___R,
7783 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
7784 where
7785 ___R: ::fidl_next::Encode<
7786 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
7787 <___T as ::fidl_next::Transport>::SendBuffer,
7788 >,
7789 {
7790 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
7791 8794297771444732717,
7792 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
7793 request,
7794 ))
7795 }
7796 }
7797
7798 #[repr(transparent)]
7800 pub struct NodeServer<___T: ::fidl_next::Transport> {
7801 server: ::fidl_next::protocol::Server<___T>,
7802 }
7803
7804 impl<___T> NodeServer<___T>
7805 where
7806 ___T: ::fidl_next::Transport,
7807 {
7808 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
7809 pub fn on_open(
7810 &self,
7811
7812 s: impl ::fidl_next::Encode<
7813 ::fidl_next::wire::fuchsia::StatusResult,
7814 <___T as ::fidl_next::Transport>::SendBuffer,
7815 >,
7816
7817 info: impl ::fidl_next::Encode<
7818 crate::wire_optional::NodeInfoDeprecated<'static>,
7819 <___T as ::fidl_next::Transport>::SendBuffer,
7820 >,
7821 ) -> ::fidl_next::SendFuture<'_, ___T>
7822 where
7823 <___T as ::fidl_next::Transport>::SendBuffer:
7824 ::fidl_next::encoder::InternalHandleEncoder,
7825 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
7826 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
7827 {
7828 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
7829 }
7830
7831 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
7832
7833 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
7834 where
7835 ___R: ::fidl_next::Encode<
7836 <super::OnOpen as ::fidl_next::Method>::Request,
7837 <___T as ::fidl_next::Transport>::SendBuffer,
7838 >,
7839 {
7840 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7841 9207534335756671346,
7842 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
7843 request,
7844 ))
7845 }
7846
7847 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
7848
7849 pub fn on_representation_with<___R>(
7850 &self,
7851 request: ___R,
7852 ) -> ::fidl_next::SendFuture<'_, ___T>
7853 where
7854 ___R: ::fidl_next::Encode<
7855 <super::OnRepresentation as ::fidl_next::Method>::Request,
7856 <___T as ::fidl_next::Transport>::SendBuffer,
7857 >,
7858 {
7859 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
7860 6679970090861613324,
7861 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
7862 request,
7863 ))
7864 }
7865 }
7866 }
7867}
7868
7869#[diagnostic::on_unimplemented(
7870 note = "If {Self} implements the non-local NodeClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
7871)]
7872
7873pub trait NodeLocalClientHandler<
7877 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
7878 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7879>
7880{
7881 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
7882 fn on_open(
7883 &mut self,
7884
7885 request: ::fidl_next::Request<node::OnOpen, ___T>,
7886 ) -> impl ::core::future::Future<Output = ()>;
7887
7888 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
7889 fn on_representation(
7890 &mut self,
7891
7892 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
7893 ) -> impl ::core::future::Future<Output = ()>;
7894
7895 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
7896 ::core::future::ready(())
7897 }
7898}
7899
7900impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Node
7901where
7902 ___H: NodeLocalClientHandler<___T>,
7903 ___T: ::fidl_next::Transport,
7904 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
7905 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7906 Constraint = (),
7907 >,
7908 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
7909 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
7910 Constraint = (),
7911 >,
7912{
7913 async fn on_event(
7914 handler: &mut ___H,
7915 mut message: ::fidl_next::Message<___T>,
7916 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
7917 match *message.header().ordinal {
7918 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7919 Ok(decoded) => {
7920 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
7921 Ok(())
7922 }
7923 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7924 ordinal: 9207534335756671346,
7925 error,
7926 }),
7927 },
7928
7929 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
7930 Ok(decoded) => {
7931 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
7932 Ok(())
7933 }
7934 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
7935 ordinal: 6679970090861613324,
7936 error,
7937 }),
7938 },
7939
7940 ordinal => {
7941 handler.on_unknown_interaction(ordinal).await;
7942 if ::core::matches!(
7943 message.header().flexibility(),
7944 ::fidl_next::protocol::Flexibility::Strict
7945 ) {
7946 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
7947 } else {
7948 Ok(())
7949 }
7950 }
7951 }
7952 }
7953}
7954
7955#[diagnostic::on_unimplemented(
7956 note = "If {Self} implements the non-local NodeServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
7957)]
7958
7959pub trait NodeLocalServerHandler<
7963 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
7964 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
7965>
7966{
7967 fn clone(
7968 &mut self,
7969
7970 request: ::fidl_next::Request<node::Clone, ___T>,
7971 ) -> impl ::core::future::Future<Output = ()>;
7972
7973 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
7974 fn close(
7975 &mut self,
7976
7977 responder: ::fidl_next::Responder<node::Close, ___T>,
7978 ) -> impl ::core::future::Future<Output = ()>;
7979
7980 fn query(
7981 &mut self,
7982
7983 responder: ::fidl_next::Responder<node::Query, ___T>,
7984 ) -> impl ::core::future::Future<Output = ()>;
7985
7986 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
7987 fn deprecated_get_attr(
7988 &mut self,
7989
7990 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
7991 ) -> impl ::core::future::Future<Output = ()>;
7992
7993 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
7994 fn deprecated_set_attr(
7995 &mut self,
7996
7997 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
7998
7999 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8000 ) -> impl ::core::future::Future<Output = ()>;
8001
8002 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
8003 fn deprecated_get_flags(
8004 &mut self,
8005
8006 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8007 ) -> impl ::core::future::Future<Output = ()>;
8008
8009 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8010 fn deprecated_set_flags(
8011 &mut self,
8012
8013 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8014
8015 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8016 ) -> impl ::core::future::Future<Output = ()>;
8017
8018 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
8019 fn get_flags(
8020 &mut self,
8021
8022 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
8023 ) -> impl ::core::future::Future<Output = ()>;
8024
8025 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
8026 fn set_flags(
8027 &mut self,
8028
8029 request: ::fidl_next::Request<node::SetFlags, ___T>,
8030
8031 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8032 ) -> impl ::core::future::Future<Output = ()>;
8033
8034 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
8035 fn query_filesystem(
8036 &mut self,
8037
8038 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8039 ) -> impl ::core::future::Future<Output = ()>;
8040
8041 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
8042 fn get_token(
8043 &mut self,
8044
8045 responder: ::fidl_next::Responder<node::GetToken, ___T>,
8046 ) -> impl ::core::future::Future<Output = ()>;
8047
8048 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8049 fn get_attributes(
8050 &mut self,
8051
8052 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8053
8054 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8055 ) -> impl ::core::future::Future<Output = ()>;
8056
8057 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8058 fn update_attributes(
8059 &mut self,
8060
8061 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8062
8063 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8064 ) -> impl ::core::future::Future<Output = ()>;
8065
8066 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
8067 fn sync(
8068 &mut self,
8069
8070 responder: ::fidl_next::Responder<node::Sync, ___T>,
8071 ) -> impl ::core::future::Future<Output = ()>;
8072
8073 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
8074 fn list_extended_attributes(
8075 &mut self,
8076
8077 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8078 ) -> impl ::core::future::Future<Output = ()>;
8079
8080 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
8081 fn get_extended_attribute(
8082 &mut self,
8083
8084 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8085
8086 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8087 ) -> impl ::core::future::Future<Output = ()>;
8088
8089 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
8090 fn set_extended_attribute(
8091 &mut self,
8092
8093 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8094
8095 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8096 ) -> impl ::core::future::Future<Output = ()>;
8097
8098 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
8099 fn remove_extended_attribute(
8100 &mut self,
8101
8102 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8103
8104 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8105 ) -> impl ::core::future::Future<Output = ()>;
8106
8107 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8108 ::core::future::ready(())
8109 }
8110}
8111
8112impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Node
8113where
8114 ___H: NodeLocalServerHandler<___T>,
8115 ___T: ::fidl_next::Transport,
8116 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8117 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8118 Constraint = (),
8119 >,
8120 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8121 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8122 Constraint = (),
8123 >,
8124 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8125 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8126 Constraint = (),
8127 >,
8128 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8129 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8130 Constraint = (),
8131 >,
8132 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8133 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8134 Constraint = (),
8135 >,
8136 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8137 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8138 Constraint = (),
8139 >,
8140 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8141 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8142 Constraint = (),
8143 >,
8144 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8145 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8146 Constraint = (),
8147 >,
8148 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8149 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8150 Constraint = (),
8151 >,
8152 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8153 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8154 Constraint = (),
8155 >,
8156{
8157 async fn on_one_way(
8158 handler: &mut ___H,
8159 mut message: ::fidl_next::Message<___T>,
8160 ) -> ::core::result::Result<
8161 (),
8162 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8163 > {
8164 match *message.header().ordinal {
8165 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8166 Ok(decoded) => {
8167 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8168 Ok(())
8169 }
8170 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8171 ordinal: 2366825959783828089,
8172 error,
8173 }),
8174 },
8175
8176 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8177 Ok(decoded) => {
8178 handler
8179 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8180 .await;
8181 Ok(())
8182 }
8183 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8184 ordinal: 5431626189872037072,
8185 error,
8186 }),
8187 },
8188
8189 ordinal => {
8190 handler.on_unknown_interaction(ordinal).await;
8191 if ::core::matches!(
8192 message.header().flexibility(),
8193 ::fidl_next::protocol::Flexibility::Strict
8194 ) {
8195 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8196 } else {
8197 Ok(())
8198 }
8199 }
8200 }
8201 }
8202
8203 async fn on_two_way(
8204 handler: &mut ___H,
8205 mut message: ::fidl_next::Message<___T>,
8206 responder: ::fidl_next::protocol::Responder<___T>,
8207 ) -> ::core::result::Result<
8208 (),
8209 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8210 > {
8211 match *message.header().ordinal {
8212 6540867515453498750 => {
8213 let responder = ::fidl_next::Responder::from_untyped(responder);
8214
8215 handler.close(responder).await;
8216 Ok(())
8217 }
8218
8219 2763219980499352582 => {
8220 let responder = ::fidl_next::Responder::from_untyped(responder);
8221
8222 handler.query(responder).await;
8223 Ok(())
8224 }
8225
8226 8689798978500614909 => {
8227 let responder = ::fidl_next::Responder::from_untyped(responder);
8228
8229 handler.deprecated_get_attr(responder).await;
8230 Ok(())
8231 }
8232
8233 4721673413776871238 => {
8234 let responder = ::fidl_next::Responder::from_untyped(responder);
8235
8236 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8237 Ok(decoded) => {
8238 handler
8239 .deprecated_set_attr(
8240 ::fidl_next::Request::from_decoded(decoded),
8241 responder,
8242 )
8243 .await;
8244 Ok(())
8245 }
8246 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8247 ordinal: 4721673413776871238,
8248 error,
8249 }),
8250 }
8251 }
8252
8253 6595803110182632097 => {
8254 let responder = ::fidl_next::Responder::from_untyped(responder);
8255
8256 handler.deprecated_get_flags(responder).await;
8257 Ok(())
8258 }
8259
8260 5950864159036794675 => {
8261 let responder = ::fidl_next::Responder::from_untyped(responder);
8262
8263 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8264 Ok(decoded) => {
8265 handler
8266 .deprecated_set_flags(
8267 ::fidl_next::Request::from_decoded(decoded),
8268 responder,
8269 )
8270 .await;
8271 Ok(())
8272 }
8273 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8274 ordinal: 5950864159036794675,
8275 error,
8276 }),
8277 }
8278 }
8279
8280 105530239381466147 => {
8281 let responder = ::fidl_next::Responder::from_untyped(responder);
8282
8283 handler.get_flags(responder).await;
8284 Ok(())
8285 }
8286
8287 6172186066099445416 => {
8288 let responder = ::fidl_next::Responder::from_untyped(responder);
8289
8290 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8291 Ok(decoded) => {
8292 handler
8293 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8294 .await;
8295 Ok(())
8296 }
8297 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8298 ordinal: 6172186066099445416,
8299 error,
8300 }),
8301 }
8302 }
8303
8304 8013111122914313744 => {
8305 let responder = ::fidl_next::Responder::from_untyped(responder);
8306
8307 handler.query_filesystem(responder).await;
8308 Ok(())
8309 }
8310
8311 5788516050773961964 => {
8312 let responder = ::fidl_next::Responder::from_untyped(responder);
8313
8314 handler.get_token(responder).await;
8315 Ok(())
8316 }
8317
8318 4414537700416816443 => {
8319 let responder = ::fidl_next::Responder::from_untyped(responder);
8320
8321 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8322 Ok(decoded) => {
8323 handler
8324 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8325 .await;
8326 Ok(())
8327 }
8328 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8329 ordinal: 4414537700416816443,
8330 error,
8331 }),
8332 }
8333 }
8334
8335 3677402239314018056 => {
8336 let responder = ::fidl_next::Responder::from_untyped(responder);
8337
8338 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8339 Ok(decoded) => {
8340 handler
8341 .update_attributes(
8342 ::fidl_next::Request::from_decoded(decoded),
8343 responder,
8344 )
8345 .await;
8346 Ok(())
8347 }
8348 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8349 ordinal: 3677402239314018056,
8350 error,
8351 }),
8352 }
8353 }
8354
8355 3196473584242777161 => {
8356 let responder = ::fidl_next::Responder::from_untyped(responder);
8357
8358 handler.sync(responder).await;
8359 Ok(())
8360 }
8361
8362 5043930208506967771 => {
8363 let responder = ::fidl_next::Responder::from_untyped(responder);
8364
8365 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8366 Ok(decoded) => {
8367 handler
8368 .get_extended_attribute(
8369 ::fidl_next::Request::from_decoded(decoded),
8370 responder,
8371 )
8372 .await;
8373 Ok(())
8374 }
8375 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8376 ordinal: 5043930208506967771,
8377 error,
8378 }),
8379 }
8380 }
8381
8382 5374223046099989052 => {
8383 let responder = ::fidl_next::Responder::from_untyped(responder);
8384
8385 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8386 Ok(decoded) => {
8387 handler
8388 .set_extended_attribute(
8389 ::fidl_next::Request::from_decoded(decoded),
8390 responder,
8391 )
8392 .await;
8393 Ok(())
8394 }
8395 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8396 ordinal: 5374223046099989052,
8397 error,
8398 }),
8399 }
8400 }
8401
8402 8794297771444732717 => {
8403 let responder = ::fidl_next::Responder::from_untyped(responder);
8404
8405 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8406 Ok(decoded) => {
8407 handler
8408 .remove_extended_attribute(
8409 ::fidl_next::Request::from_decoded(decoded),
8410 responder,
8411 )
8412 .await;
8413 Ok(())
8414 }
8415 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8416 ordinal: 8794297771444732717,
8417 error,
8418 }),
8419 }
8420 }
8421
8422 ordinal => {
8423 handler.on_unknown_interaction(ordinal).await;
8424 if ::core::matches!(
8425 message.header().flexibility(),
8426 ::fidl_next::protocol::Flexibility::Strict
8427 ) {
8428 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8429 } else {
8430 responder
8431 .respond_framework_error(
8432 ordinal,
8433 ::fidl_next::FrameworkError::UnknownMethod,
8434 )
8435 .expect("encoding a framework error should never fail")
8436 .await?;
8437 Ok(())
8438 }
8439 }
8440 }
8441 }
8442}
8443
8444pub trait NodeClientHandler<
8448 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8449 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8450>
8451{
8452 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
8453 fn on_open(
8454 &mut self,
8455
8456 request: ::fidl_next::Request<node::OnOpen, ___T>,
8457 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8458
8459 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
8460 fn on_representation(
8461 &mut self,
8462
8463 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
8464 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8465
8466 fn on_unknown_interaction(
8467 &mut self,
8468 ordinal: u64,
8469 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8470 ::core::future::ready(())
8471 }
8472}
8473
8474impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Node
8475where
8476 ___H: NodeClientHandler<___T> + ::core::marker::Send,
8477 ___T: ::fidl_next::Transport,
8478 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
8479 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8480 Constraint = (),
8481 >,
8482 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
8483 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8484 Constraint = (),
8485 >,
8486{
8487 async fn on_event(
8488 handler: &mut ___H,
8489 mut message: ::fidl_next::Message<___T>,
8490 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8491 match *message.header().ordinal {
8492 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8493 Ok(decoded) => {
8494 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
8495 Ok(())
8496 }
8497 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8498 ordinal: 9207534335756671346,
8499 error,
8500 }),
8501 },
8502
8503 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8504 Ok(decoded) => {
8505 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
8506 Ok(())
8507 }
8508 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8509 ordinal: 6679970090861613324,
8510 error,
8511 }),
8512 },
8513
8514 ordinal => {
8515 handler.on_unknown_interaction(ordinal).await;
8516 if ::core::matches!(
8517 message.header().flexibility(),
8518 ::fidl_next::protocol::Flexibility::Strict
8519 ) {
8520 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8521 } else {
8522 Ok(())
8523 }
8524 }
8525 }
8526 }
8527}
8528
8529pub trait NodeServerHandler<
8533 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8534 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8535>
8536{
8537 fn clone(
8538 &mut self,
8539
8540 request: ::fidl_next::Request<node::Clone, ___T>,
8541 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8542
8543 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
8544 fn close(
8545 &mut self,
8546
8547 responder: ::fidl_next::Responder<node::Close, ___T>,
8548 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8549
8550 fn query(
8551 &mut self,
8552
8553 responder: ::fidl_next::Responder<node::Query, ___T>,
8554 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8555
8556 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8557 fn deprecated_get_attr(
8558 &mut self,
8559
8560 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
8561 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8562
8563 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
8564 fn deprecated_set_attr(
8565 &mut self,
8566
8567 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
8568
8569 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
8570 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8571
8572 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
8573 fn deprecated_get_flags(
8574 &mut self,
8575
8576 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
8577 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8578
8579 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
8580 fn deprecated_set_flags(
8581 &mut self,
8582
8583 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
8584
8585 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
8586 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8587
8588 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
8589 fn get_flags(
8590 &mut self,
8591
8592 responder: ::fidl_next::Responder<node::GetFlags, ___T>,
8593 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8594
8595 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
8596 fn set_flags(
8597 &mut self,
8598
8599 request: ::fidl_next::Request<node::SetFlags, ___T>,
8600
8601 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
8602 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8603
8604 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
8605 fn query_filesystem(
8606 &mut self,
8607
8608 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
8609 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8610
8611 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
8612 fn get_token(
8613 &mut self,
8614
8615 responder: ::fidl_next::Responder<node::GetToken, ___T>,
8616 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8617
8618 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
8619 fn get_attributes(
8620 &mut self,
8621
8622 request: ::fidl_next::Request<node::GetAttributes, ___T>,
8623
8624 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
8625 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8626
8627 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
8628 fn update_attributes(
8629 &mut self,
8630
8631 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
8632
8633 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
8634 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8635
8636 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
8637 fn sync(
8638 &mut self,
8639
8640 responder: ::fidl_next::Responder<node::Sync, ___T>,
8641 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8642
8643 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
8644 fn list_extended_attributes(
8645 &mut self,
8646
8647 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
8648 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8649
8650 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
8651 fn get_extended_attribute(
8652 &mut self,
8653
8654 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
8655
8656 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
8657 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8658
8659 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
8660 fn set_extended_attribute(
8661 &mut self,
8662
8663 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
8664
8665 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
8666 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8667
8668 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
8669 fn remove_extended_attribute(
8670 &mut self,
8671
8672 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
8673
8674 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
8675 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8676
8677 fn on_unknown_interaction(
8678 &mut self,
8679 ordinal: u64,
8680 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8681 ::core::future::ready(())
8682 }
8683}
8684
8685impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Node
8686where
8687 ___H: NodeServerHandler<___T> + ::core::marker::Send,
8688 ___T: ::fidl_next::Transport,
8689 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
8690 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8691 Constraint = (),
8692 >,
8693 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
8694 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8695 Constraint = (),
8696 >,
8697 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
8698 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8699 Constraint = (),
8700 >,
8701 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
8702 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8703 Constraint = (),
8704 >,
8705 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
8706 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8707 Constraint = (),
8708 >,
8709 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
8710 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8711 Constraint = (),
8712 >,
8713 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
8714 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8715 Constraint = (),
8716 >,
8717 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8718 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8719 Constraint = (),
8720 >,
8721 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8722 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8723 Constraint = (),
8724 >,
8725 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
8726 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8727 Constraint = (),
8728 >,
8729{
8730 async fn on_one_way(
8731 handler: &mut ___H,
8732 mut message: ::fidl_next::Message<___T>,
8733 ) -> ::core::result::Result<
8734 (),
8735 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8736 > {
8737 match *message.header().ordinal {
8738 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8739 Ok(decoded) => {
8740 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
8741 Ok(())
8742 }
8743 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8744 ordinal: 2366825959783828089,
8745 error,
8746 }),
8747 },
8748
8749 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
8750 Ok(decoded) => {
8751 handler
8752 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
8753 .await;
8754 Ok(())
8755 }
8756 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8757 ordinal: 5431626189872037072,
8758 error,
8759 }),
8760 },
8761
8762 ordinal => {
8763 handler.on_unknown_interaction(ordinal).await;
8764 if ::core::matches!(
8765 message.header().flexibility(),
8766 ::fidl_next::protocol::Flexibility::Strict
8767 ) {
8768 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8769 } else {
8770 Ok(())
8771 }
8772 }
8773 }
8774 }
8775
8776 async fn on_two_way(
8777 handler: &mut ___H,
8778 mut message: ::fidl_next::Message<___T>,
8779 responder: ::fidl_next::protocol::Responder<___T>,
8780 ) -> ::core::result::Result<
8781 (),
8782 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8783 > {
8784 match *message.header().ordinal {
8785 6540867515453498750 => {
8786 let responder = ::fidl_next::Responder::from_untyped(responder);
8787
8788 handler.close(responder).await;
8789 Ok(())
8790 }
8791
8792 2763219980499352582 => {
8793 let responder = ::fidl_next::Responder::from_untyped(responder);
8794
8795 handler.query(responder).await;
8796 Ok(())
8797 }
8798
8799 8689798978500614909 => {
8800 let responder = ::fidl_next::Responder::from_untyped(responder);
8801
8802 handler.deprecated_get_attr(responder).await;
8803 Ok(())
8804 }
8805
8806 4721673413776871238 => {
8807 let responder = ::fidl_next::Responder::from_untyped(responder);
8808
8809 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8810 Ok(decoded) => {
8811 handler
8812 .deprecated_set_attr(
8813 ::fidl_next::Request::from_decoded(decoded),
8814 responder,
8815 )
8816 .await;
8817 Ok(())
8818 }
8819 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8820 ordinal: 4721673413776871238,
8821 error,
8822 }),
8823 }
8824 }
8825
8826 6595803110182632097 => {
8827 let responder = ::fidl_next::Responder::from_untyped(responder);
8828
8829 handler.deprecated_get_flags(responder).await;
8830 Ok(())
8831 }
8832
8833 5950864159036794675 => {
8834 let responder = ::fidl_next::Responder::from_untyped(responder);
8835
8836 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8837 Ok(decoded) => {
8838 handler
8839 .deprecated_set_flags(
8840 ::fidl_next::Request::from_decoded(decoded),
8841 responder,
8842 )
8843 .await;
8844 Ok(())
8845 }
8846 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8847 ordinal: 5950864159036794675,
8848 error,
8849 }),
8850 }
8851 }
8852
8853 105530239381466147 => {
8854 let responder = ::fidl_next::Responder::from_untyped(responder);
8855
8856 handler.get_flags(responder).await;
8857 Ok(())
8858 }
8859
8860 6172186066099445416 => {
8861 let responder = ::fidl_next::Responder::from_untyped(responder);
8862
8863 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8864 Ok(decoded) => {
8865 handler
8866 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
8867 .await;
8868 Ok(())
8869 }
8870 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8871 ordinal: 6172186066099445416,
8872 error,
8873 }),
8874 }
8875 }
8876
8877 8013111122914313744 => {
8878 let responder = ::fidl_next::Responder::from_untyped(responder);
8879
8880 handler.query_filesystem(responder).await;
8881 Ok(())
8882 }
8883
8884 5788516050773961964 => {
8885 let responder = ::fidl_next::Responder::from_untyped(responder);
8886
8887 handler.get_token(responder).await;
8888 Ok(())
8889 }
8890
8891 4414537700416816443 => {
8892 let responder = ::fidl_next::Responder::from_untyped(responder);
8893
8894 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8895 Ok(decoded) => {
8896 handler
8897 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
8898 .await;
8899 Ok(())
8900 }
8901 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8902 ordinal: 4414537700416816443,
8903 error,
8904 }),
8905 }
8906 }
8907
8908 3677402239314018056 => {
8909 let responder = ::fidl_next::Responder::from_untyped(responder);
8910
8911 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8912 Ok(decoded) => {
8913 handler
8914 .update_attributes(
8915 ::fidl_next::Request::from_decoded(decoded),
8916 responder,
8917 )
8918 .await;
8919 Ok(())
8920 }
8921 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8922 ordinal: 3677402239314018056,
8923 error,
8924 }),
8925 }
8926 }
8927
8928 3196473584242777161 => {
8929 let responder = ::fidl_next::Responder::from_untyped(responder);
8930
8931 handler.sync(responder).await;
8932 Ok(())
8933 }
8934
8935 5043930208506967771 => {
8936 let responder = ::fidl_next::Responder::from_untyped(responder);
8937
8938 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8939 Ok(decoded) => {
8940 handler
8941 .get_extended_attribute(
8942 ::fidl_next::Request::from_decoded(decoded),
8943 responder,
8944 )
8945 .await;
8946 Ok(())
8947 }
8948 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8949 ordinal: 5043930208506967771,
8950 error,
8951 }),
8952 }
8953 }
8954
8955 5374223046099989052 => {
8956 let responder = ::fidl_next::Responder::from_untyped(responder);
8957
8958 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8959 Ok(decoded) => {
8960 handler
8961 .set_extended_attribute(
8962 ::fidl_next::Request::from_decoded(decoded),
8963 responder,
8964 )
8965 .await;
8966 Ok(())
8967 }
8968 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8969 ordinal: 5374223046099989052,
8970 error,
8971 }),
8972 }
8973 }
8974
8975 8794297771444732717 => {
8976 let responder = ::fidl_next::Responder::from_untyped(responder);
8977
8978 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8979 Ok(decoded) => {
8980 handler
8981 .remove_extended_attribute(
8982 ::fidl_next::Request::from_decoded(decoded),
8983 responder,
8984 )
8985 .await;
8986 Ok(())
8987 }
8988 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8989 ordinal: 8794297771444732717,
8990 error,
8991 }),
8992 }
8993 }
8994
8995 ordinal => {
8996 handler.on_unknown_interaction(ordinal).await;
8997 if ::core::matches!(
8998 message.header().flexibility(),
8999 ::fidl_next::protocol::Flexibility::Strict
9000 ) {
9001 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9002 } else {
9003 responder
9004 .respond_framework_error(
9005 ordinal,
9006 ::fidl_next::FrameworkError::UnknownMethod,
9007 )
9008 .expect("encoding a framework error should never fail")
9009 .await?;
9010 Ok(())
9011 }
9012 }
9013 }
9014 }
9015}
9016
9017impl<___T> NodeClientHandler<___T> for ::fidl_next::IgnoreEvents
9018where
9019 ___T: ::fidl_next::Transport,
9020{
9021 async fn on_open(&mut self, _: ::fidl_next::Request<node::OnOpen, ___T>) {}
9022
9023 async fn on_representation(&mut self, _: ::fidl_next::Request<node::OnRepresentation, ___T>) {}
9024
9025 async fn on_unknown_interaction(&mut self, _: u64) {}
9026}
9027
9028impl<___H, ___T> NodeLocalClientHandler<___T> for ::fidl_next::Local<___H>
9029where
9030 ___H: NodeClientHandler<___T>,
9031 ___T: ::fidl_next::Transport,
9032{
9033 async fn on_open(&mut self, request: ::fidl_next::Request<node::OnOpen, ___T>) {
9034 ___H::on_open(&mut self.0, request).await
9035 }
9036
9037 async fn on_representation(
9038 &mut self,
9039
9040 request: ::fidl_next::Request<node::OnRepresentation, ___T>,
9041 ) {
9042 ___H::on_representation(&mut self.0, request).await
9043 }
9044
9045 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9046 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9047 }
9048}
9049
9050impl<___H, ___T> NodeLocalServerHandler<___T> for ::fidl_next::Local<___H>
9051where
9052 ___H: NodeServerHandler<___T>,
9053 ___T: ::fidl_next::Transport,
9054{
9055 async fn clone(&mut self, request: ::fidl_next::Request<node::Clone, ___T>) {
9056 ___H::clone(&mut self.0, request).await
9057 }
9058
9059 async fn close(&mut self, responder: ::fidl_next::Responder<node::Close, ___T>) {
9060 ___H::close(&mut self.0, responder).await
9061 }
9062
9063 async fn query(&mut self, responder: ::fidl_next::Responder<node::Query, ___T>) {
9064 ___H::query(&mut self.0, responder).await
9065 }
9066
9067 async fn deprecated_get_attr(
9068 &mut self,
9069
9070 responder: ::fidl_next::Responder<node::DeprecatedGetAttr, ___T>,
9071 ) {
9072 ___H::deprecated_get_attr(&mut self.0, responder).await
9073 }
9074
9075 async fn deprecated_set_attr(
9076 &mut self,
9077
9078 request: ::fidl_next::Request<node::DeprecatedSetAttr, ___T>,
9079
9080 responder: ::fidl_next::Responder<node::DeprecatedSetAttr, ___T>,
9081 ) {
9082 ___H::deprecated_set_attr(&mut self.0, request, responder).await
9083 }
9084
9085 async fn deprecated_get_flags(
9086 &mut self,
9087
9088 responder: ::fidl_next::Responder<node::DeprecatedGetFlags, ___T>,
9089 ) {
9090 ___H::deprecated_get_flags(&mut self.0, responder).await
9091 }
9092
9093 async fn deprecated_set_flags(
9094 &mut self,
9095
9096 request: ::fidl_next::Request<node::DeprecatedSetFlags, ___T>,
9097
9098 responder: ::fidl_next::Responder<node::DeprecatedSetFlags, ___T>,
9099 ) {
9100 ___H::deprecated_set_flags(&mut self.0, request, responder).await
9101 }
9102
9103 async fn get_flags(&mut self, responder: ::fidl_next::Responder<node::GetFlags, ___T>) {
9104 ___H::get_flags(&mut self.0, responder).await
9105 }
9106
9107 async fn set_flags(
9108 &mut self,
9109
9110 request: ::fidl_next::Request<node::SetFlags, ___T>,
9111
9112 responder: ::fidl_next::Responder<node::SetFlags, ___T>,
9113 ) {
9114 ___H::set_flags(&mut self.0, request, responder).await
9115 }
9116
9117 async fn query_filesystem(
9118 &mut self,
9119
9120 responder: ::fidl_next::Responder<node::QueryFilesystem, ___T>,
9121 ) {
9122 ___H::query_filesystem(&mut self.0, responder).await
9123 }
9124
9125 async fn get_token(&mut self, responder: ::fidl_next::Responder<node::GetToken, ___T>) {
9126 ___H::get_token(&mut self.0, responder).await
9127 }
9128
9129 async fn get_attributes(
9130 &mut self,
9131
9132 request: ::fidl_next::Request<node::GetAttributes, ___T>,
9133
9134 responder: ::fidl_next::Responder<node::GetAttributes, ___T>,
9135 ) {
9136 ___H::get_attributes(&mut self.0, request, responder).await
9137 }
9138
9139 async fn update_attributes(
9140 &mut self,
9141
9142 request: ::fidl_next::Request<node::UpdateAttributes, ___T>,
9143
9144 responder: ::fidl_next::Responder<node::UpdateAttributes, ___T>,
9145 ) {
9146 ___H::update_attributes(&mut self.0, request, responder).await
9147 }
9148
9149 async fn sync(&mut self, responder: ::fidl_next::Responder<node::Sync, ___T>) {
9150 ___H::sync(&mut self.0, responder).await
9151 }
9152
9153 async fn list_extended_attributes(
9154 &mut self,
9155
9156 request: ::fidl_next::Request<node::ListExtendedAttributes, ___T>,
9157 ) {
9158 ___H::list_extended_attributes(&mut self.0, request).await
9159 }
9160
9161 async fn get_extended_attribute(
9162 &mut self,
9163
9164 request: ::fidl_next::Request<node::GetExtendedAttribute, ___T>,
9165
9166 responder: ::fidl_next::Responder<node::GetExtendedAttribute, ___T>,
9167 ) {
9168 ___H::get_extended_attribute(&mut self.0, request, responder).await
9169 }
9170
9171 async fn set_extended_attribute(
9172 &mut self,
9173
9174 request: ::fidl_next::Request<node::SetExtendedAttribute, ___T>,
9175
9176 responder: ::fidl_next::Responder<node::SetExtendedAttribute, ___T>,
9177 ) {
9178 ___H::set_extended_attribute(&mut self.0, request, responder).await
9179 }
9180
9181 async fn remove_extended_attribute(
9182 &mut self,
9183
9184 request: ::fidl_next::Request<node::RemoveExtendedAttribute, ___T>,
9185
9186 responder: ::fidl_next::Responder<node::RemoveExtendedAttribute, ___T>,
9187 ) {
9188 ___H::remove_extended_attribute(&mut self.0, request, responder).await
9189 }
9190
9191 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9192 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9193 }
9194}
9195
9196#[doc = " Directory defines a node which is capable of containing other Objects.\n"]
9198#[derive(PartialEq, Debug)]
9199pub struct Directory;
9200
9201impl ::fidl_next::Discoverable for Directory {
9202 const PROTOCOL_NAME: &'static str = "fuchsia.io.Directory";
9203}
9204
9205#[cfg(target_os = "fuchsia")]
9206impl ::fidl_next::HasTransport for Directory {
9207 type Transport = ::fidl_next::fuchsia::zx::Channel;
9208}
9209
9210pub mod directory {
9211 pub mod prelude {
9212 pub use crate::{
9213 Directory, DirectoryClientHandler, DirectoryLocalClientHandler,
9214 DirectoryLocalServerHandler, DirectoryServerHandler, directory,
9215 };
9216
9217 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
9218
9219 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
9220
9221 pub use crate::natural::DirectoryCreateSymlinkRequest;
9222
9223 pub use crate::natural::DirectoryDeprecatedGetTokenResponse;
9224
9225 pub use crate::natural::DirectoryDeprecatedOpenRequest;
9226
9227 pub use crate::natural::DirectoryLinkRequest;
9228
9229 pub use crate::natural::DirectoryLinkResponse;
9230
9231 pub use crate::natural::DirectoryReadDirentsRequest;
9232
9233 pub use crate::natural::DirectoryReadDirentsResponse;
9234
9235 pub use crate::natural::DirectoryRenameRequest;
9236
9237 pub use crate::natural::DirectoryRewindResponse;
9238
9239 pub use crate::natural::DirectoryUnlinkRequest;
9240
9241 pub use crate::natural::DirectoryWatchRequest;
9242
9243 pub use crate::natural::DirectoryWatchResponse;
9244
9245 pub use crate::natural::DirectoryCreateSymlinkResponse;
9246
9247 pub use crate::natural::DirectoryRenameResponse;
9248
9249 pub use crate::natural::DirectoryUnlinkResponse;
9250
9251 pub use crate::natural::ExtendedAttributeValue;
9252
9253 pub use crate::natural::MutableNodeAttributes;
9254
9255 pub use crate::natural::NodeAttributes2;
9256
9257 pub use crate::natural::NodeDeprecatedGetAttrResponse;
9258
9259 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
9260
9261 pub use crate::natural::NodeDeprecatedSetAttrRequest;
9262
9263 pub use crate::natural::NodeDeprecatedSetAttrResponse;
9264
9265 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
9266
9267 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
9268
9269 pub use crate::natural::NodeGetAttributesRequest;
9270
9271 pub use crate::natural::NodeGetExtendedAttributeRequest;
9272
9273 pub use crate::natural::NodeListExtendedAttributesRequest;
9274
9275 pub use crate::natural::NodeOnOpenRequest;
9276
9277 pub use crate::natural::NodeQueryFilesystemResponse;
9278
9279 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
9280
9281 pub use crate::natural::NodeSetExtendedAttributeRequest;
9282
9283 pub use crate::natural::NodeSetFlagsRequest;
9284
9285 pub use crate::natural::NodeGetFlagsResponse;
9286
9287 pub use crate::natural::NodeGetTokenResponse;
9288
9289 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
9290
9291 pub use crate::natural::NodeSetExtendedAttributeResponse;
9292
9293 pub use crate::natural::NodeSetFlagsResponse;
9294
9295 pub use crate::natural::NodeSyncResponse;
9296
9297 pub use crate::natural::NodeUpdateAttributesResponse;
9298
9299 pub use crate::natural::OpenableOpenRequest;
9300
9301 pub use crate::natural::Representation;
9302
9303 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
9304
9305 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
9306
9307 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
9308 }
9309
9310 pub struct AdvisoryLock;
9311
9312 impl ::fidl_next::Method for AdvisoryLock {
9313 const ORDINAL: u64 = 7992130864415541162;
9314 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9315 ::fidl_next::protocol::Flexibility::Strict;
9316
9317 type Protocol = crate::Directory;
9318
9319 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
9320 }
9321
9322 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
9323 type Response = ::fidl_next::wire::Result<
9324 'static,
9325 crate::wire::AdvisoryLockingAdvisoryLockResponse,
9326 ::fidl_next::wire::fuchsia::Status,
9327 >;
9328 }
9329
9330 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
9331 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9332
9333 fn respond(response: ___R) -> Self::Output {
9334 ::core::result::Result::Ok(response)
9335 }
9336 }
9337
9338 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
9339 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9340
9341 fn respond_err(response: ___R) -> Self::Output {
9342 ::core::result::Result::Err(response)
9343 }
9344 }
9345
9346 pub struct Clone;
9347
9348 impl ::fidl_next::Method for Clone {
9349 const ORDINAL: u64 = 2366825959783828089;
9350 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9351 ::fidl_next::protocol::Flexibility::Strict;
9352
9353 type Protocol = crate::Directory;
9354
9355 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
9356 }
9357
9358 pub struct Close;
9359
9360 impl ::fidl_next::Method for Close {
9361 const ORDINAL: u64 = 6540867515453498750;
9362 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9363 ::fidl_next::protocol::Flexibility::Strict;
9364
9365 type Protocol = crate::Directory;
9366
9367 type Request = ::fidl_next::wire::EmptyMessageBody;
9368 }
9369
9370 impl ::fidl_next::TwoWayMethod for Close {
9371 type Response = ::fidl_next::wire::Result<
9372 'static,
9373 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
9374 ::fidl_next::wire::Int32,
9375 >;
9376 }
9377
9378 impl<___R> ::fidl_next::Respond<___R> for Close {
9379 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9380
9381 fn respond(response: ___R) -> Self::Output {
9382 ::core::result::Result::Ok(response)
9383 }
9384 }
9385
9386 impl<___R> ::fidl_next::RespondErr<___R> for Close {
9387 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9388
9389 fn respond_err(response: ___R) -> Self::Output {
9390 ::core::result::Result::Err(response)
9391 }
9392 }
9393
9394 pub struct Query;
9395
9396 impl ::fidl_next::Method for Query {
9397 const ORDINAL: u64 = 2763219980499352582;
9398 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9399 ::fidl_next::protocol::Flexibility::Strict;
9400
9401 type Protocol = crate::Directory;
9402
9403 type Request = ::fidl_next::wire::EmptyMessageBody;
9404 }
9405
9406 impl ::fidl_next::TwoWayMethod for Query {
9407 type Response = ::fidl_next::wire::Strict<
9408 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
9409 >;
9410 }
9411
9412 impl<___R> ::fidl_next::Respond<___R> for Query {
9413 type Output =
9414 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
9415
9416 fn respond(response: ___R) -> Self::Output {
9417 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
9418 protocol: response,
9419 })
9420 }
9421 }
9422
9423 pub struct OnOpen;
9424
9425 impl ::fidl_next::Method for OnOpen {
9426 const ORDINAL: u64 = 9207534335756671346;
9427 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9428 ::fidl_next::protocol::Flexibility::Flexible;
9429
9430 type Protocol = crate::Directory;
9431
9432 type Request = crate::wire::NodeOnOpenRequest<'static>;
9433 }
9434
9435 pub struct DeprecatedGetAttr;
9436
9437 impl ::fidl_next::Method for DeprecatedGetAttr {
9438 const ORDINAL: u64 = 8689798978500614909;
9439 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9440 ::fidl_next::protocol::Flexibility::Strict;
9441
9442 type Protocol = crate::Directory;
9443
9444 type Request = ::fidl_next::wire::EmptyMessageBody;
9445 }
9446
9447 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
9448 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
9449 }
9450
9451 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
9452 type Output = ::fidl_next::Strict<___R>;
9453
9454 fn respond(response: ___R) -> Self::Output {
9455 ::fidl_next::Strict(response)
9456 }
9457 }
9458
9459 pub struct DeprecatedSetAttr;
9460
9461 impl ::fidl_next::Method for DeprecatedSetAttr {
9462 const ORDINAL: u64 = 4721673413776871238;
9463 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9464 ::fidl_next::protocol::Flexibility::Strict;
9465
9466 type Protocol = crate::Directory;
9467
9468 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
9469 }
9470
9471 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
9472 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
9473 }
9474
9475 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
9476 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
9477
9478 fn respond(response: ___R) -> Self::Output {
9479 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
9480 }
9481 }
9482
9483 pub struct DeprecatedGetFlags;
9484
9485 impl ::fidl_next::Method for DeprecatedGetFlags {
9486 const ORDINAL: u64 = 6595803110182632097;
9487 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9488 ::fidl_next::protocol::Flexibility::Strict;
9489
9490 type Protocol = crate::Directory;
9491
9492 type Request = ::fidl_next::wire::EmptyMessageBody;
9493 }
9494
9495 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
9496 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
9497 }
9498
9499 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
9500 type Output = ::fidl_next::Strict<___R>;
9501
9502 fn respond(response: ___R) -> Self::Output {
9503 ::fidl_next::Strict(response)
9504 }
9505 }
9506
9507 pub struct DeprecatedSetFlags;
9508
9509 impl ::fidl_next::Method for DeprecatedSetFlags {
9510 const ORDINAL: u64 = 5950864159036794675;
9511 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9512 ::fidl_next::protocol::Flexibility::Strict;
9513
9514 type Protocol = crate::Directory;
9515
9516 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
9517 }
9518
9519 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
9520 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
9521 }
9522
9523 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
9524 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
9525
9526 fn respond(response: ___R) -> Self::Output {
9527 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
9528 }
9529 }
9530
9531 pub struct GetFlags;
9532
9533 impl ::fidl_next::Method for GetFlags {
9534 const ORDINAL: u64 = 105530239381466147;
9535 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9536 ::fidl_next::protocol::Flexibility::Flexible;
9537
9538 type Protocol = crate::Directory;
9539
9540 type Request = ::fidl_next::wire::EmptyMessageBody;
9541 }
9542
9543 impl ::fidl_next::TwoWayMethod for GetFlags {
9544 type Response = ::fidl_next::wire::Result<
9545 'static,
9546 crate::wire::NodeGetFlagsResponse,
9547 ::fidl_next::wire::fuchsia::Status,
9548 >;
9549 }
9550
9551 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
9552 type Output = ::core::result::Result<
9553 crate::generic::NodeGetFlagsResponse<___R>,
9554 ::fidl_next::never::Never,
9555 >;
9556
9557 fn respond(response: ___R) -> Self::Output {
9558 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
9559 }
9560 }
9561
9562 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
9563 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9564
9565 fn respond_err(response: ___R) -> Self::Output {
9566 ::core::result::Result::Err(response)
9567 }
9568 }
9569
9570 pub struct SetFlags;
9571
9572 impl ::fidl_next::Method for SetFlags {
9573 const ORDINAL: u64 = 6172186066099445416;
9574 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9575 ::fidl_next::protocol::Flexibility::Flexible;
9576
9577 type Protocol = crate::Directory;
9578
9579 type Request = crate::wire::NodeSetFlagsRequest;
9580 }
9581
9582 impl ::fidl_next::TwoWayMethod for SetFlags {
9583 type Response = ::fidl_next::wire::Result<
9584 'static,
9585 crate::wire::NodeSetFlagsResponse,
9586 ::fidl_next::wire::fuchsia::Status,
9587 >;
9588 }
9589
9590 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
9591 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9592
9593 fn respond(response: ___R) -> Self::Output {
9594 ::core::result::Result::Ok(response)
9595 }
9596 }
9597
9598 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
9599 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9600
9601 fn respond_err(response: ___R) -> Self::Output {
9602 ::core::result::Result::Err(response)
9603 }
9604 }
9605
9606 pub struct QueryFilesystem;
9607
9608 impl ::fidl_next::Method for QueryFilesystem {
9609 const ORDINAL: u64 = 8013111122914313744;
9610 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9611 ::fidl_next::protocol::Flexibility::Strict;
9612
9613 type Protocol = crate::Directory;
9614
9615 type Request = ::fidl_next::wire::EmptyMessageBody;
9616 }
9617
9618 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
9619 type Response =
9620 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
9621 }
9622
9623 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
9624 type Output = ::fidl_next::Strict<___R>;
9625
9626 fn respond(response: ___R) -> Self::Output {
9627 ::fidl_next::Strict(response)
9628 }
9629 }
9630
9631 pub struct OnRepresentation;
9632
9633 impl ::fidl_next::Method for OnRepresentation {
9634 const ORDINAL: u64 = 6679970090861613324;
9635 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9636 ::fidl_next::protocol::Flexibility::Strict;
9637
9638 type Protocol = crate::Directory;
9639
9640 type Request = crate::wire::Representation<'static>;
9641 }
9642
9643 pub struct GetToken;
9644
9645 impl ::fidl_next::Method for GetToken {
9646 const ORDINAL: u64 = 5788516050773961964;
9647 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9648 ::fidl_next::protocol::Flexibility::Flexible;
9649
9650 type Protocol = crate::Directory;
9651
9652 type Request = ::fidl_next::wire::EmptyMessageBody;
9653 }
9654
9655 impl ::fidl_next::TwoWayMethod for GetToken {
9656 type Response = ::fidl_next::wire::Result<
9657 'static,
9658 crate::wire::NodeGetTokenResponse,
9659 ::fidl_next::wire::fuchsia::Status,
9660 >;
9661 }
9662
9663 impl<___R> ::fidl_next::Respond<___R> for GetToken {
9664 type Output = ::core::result::Result<
9665 crate::generic::NodeGetTokenResponse<___R>,
9666 ::fidl_next::never::Never,
9667 >;
9668
9669 fn respond(response: ___R) -> Self::Output {
9670 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
9671 }
9672 }
9673
9674 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
9675 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9676
9677 fn respond_err(response: ___R) -> Self::Output {
9678 ::core::result::Result::Err(response)
9679 }
9680 }
9681
9682 pub struct GetAttributes;
9683
9684 impl ::fidl_next::Method for GetAttributes {
9685 const ORDINAL: u64 = 4414537700416816443;
9686 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9687 ::fidl_next::protocol::Flexibility::Strict;
9688
9689 type Protocol = crate::Directory;
9690
9691 type Request = crate::wire::NodeGetAttributesRequest;
9692 }
9693
9694 impl ::fidl_next::TwoWayMethod for GetAttributes {
9695 type Response = ::fidl_next::wire::Result<
9696 'static,
9697 crate::wire::NodeAttributes2<'static>,
9698 ::fidl_next::wire::fuchsia::Status,
9699 >;
9700 }
9701
9702 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
9703 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9704
9705 fn respond(response: ___R) -> Self::Output {
9706 ::core::result::Result::Ok(response)
9707 }
9708 }
9709
9710 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
9711 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9712
9713 fn respond_err(response: ___R) -> Self::Output {
9714 ::core::result::Result::Err(response)
9715 }
9716 }
9717
9718 pub struct UpdateAttributes;
9719
9720 impl ::fidl_next::Method for UpdateAttributes {
9721 const ORDINAL: u64 = 3677402239314018056;
9722 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9723 ::fidl_next::protocol::Flexibility::Strict;
9724
9725 type Protocol = crate::Directory;
9726
9727 type Request = crate::wire::MutableNodeAttributes<'static>;
9728 }
9729
9730 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
9731 type Response = ::fidl_next::wire::Result<
9732 'static,
9733 crate::wire::NodeUpdateAttributesResponse,
9734 ::fidl_next::wire::fuchsia::Status,
9735 >;
9736 }
9737
9738 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
9739 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9740
9741 fn respond(response: ___R) -> Self::Output {
9742 ::core::result::Result::Ok(response)
9743 }
9744 }
9745
9746 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
9747 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9748
9749 fn respond_err(response: ___R) -> Self::Output {
9750 ::core::result::Result::Err(response)
9751 }
9752 }
9753
9754 pub struct Sync;
9755
9756 impl ::fidl_next::Method for Sync {
9757 const ORDINAL: u64 = 3196473584242777161;
9758 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9759 ::fidl_next::protocol::Flexibility::Strict;
9760
9761 type Protocol = crate::Directory;
9762
9763 type Request = ::fidl_next::wire::EmptyMessageBody;
9764 }
9765
9766 impl ::fidl_next::TwoWayMethod for Sync {
9767 type Response = ::fidl_next::wire::Result<
9768 'static,
9769 crate::wire::NodeSyncResponse,
9770 ::fidl_next::wire::fuchsia::Status,
9771 >;
9772 }
9773
9774 impl<___R> ::fidl_next::Respond<___R> for Sync {
9775 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9776
9777 fn respond(response: ___R) -> Self::Output {
9778 ::core::result::Result::Ok(response)
9779 }
9780 }
9781
9782 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
9783 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9784
9785 fn respond_err(response: ___R) -> Self::Output {
9786 ::core::result::Result::Err(response)
9787 }
9788 }
9789
9790 pub struct ListExtendedAttributes;
9791
9792 impl ::fidl_next::Method for ListExtendedAttributes {
9793 const ORDINAL: u64 = 5431626189872037072;
9794 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9795 ::fidl_next::protocol::Flexibility::Strict;
9796
9797 type Protocol = crate::Directory;
9798
9799 type Request = crate::wire::NodeListExtendedAttributesRequest;
9800 }
9801
9802 pub struct GetExtendedAttribute;
9803
9804 impl ::fidl_next::Method for GetExtendedAttribute {
9805 const ORDINAL: u64 = 5043930208506967771;
9806 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9807 ::fidl_next::protocol::Flexibility::Strict;
9808
9809 type Protocol = crate::Directory;
9810
9811 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
9812 }
9813
9814 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
9815 type Response = ::fidl_next::wire::Result<
9816 'static,
9817 crate::wire::ExtendedAttributeValue<'static>,
9818 ::fidl_next::wire::fuchsia::Status,
9819 >;
9820 }
9821
9822 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
9823 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9824
9825 fn respond(response: ___R) -> Self::Output {
9826 ::core::result::Result::Ok(response)
9827 }
9828 }
9829
9830 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
9831 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9832
9833 fn respond_err(response: ___R) -> Self::Output {
9834 ::core::result::Result::Err(response)
9835 }
9836 }
9837
9838 pub struct SetExtendedAttribute;
9839
9840 impl ::fidl_next::Method for SetExtendedAttribute {
9841 const ORDINAL: u64 = 5374223046099989052;
9842 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9843 ::fidl_next::protocol::Flexibility::Strict;
9844
9845 type Protocol = crate::Directory;
9846
9847 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
9848 }
9849
9850 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
9851 type Response = ::fidl_next::wire::Result<
9852 'static,
9853 crate::wire::NodeSetExtendedAttributeResponse,
9854 ::fidl_next::wire::fuchsia::Status,
9855 >;
9856 }
9857
9858 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
9859 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9860
9861 fn respond(response: ___R) -> Self::Output {
9862 ::core::result::Result::Ok(response)
9863 }
9864 }
9865
9866 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
9867 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9868
9869 fn respond_err(response: ___R) -> Self::Output {
9870 ::core::result::Result::Err(response)
9871 }
9872 }
9873
9874 pub struct RemoveExtendedAttribute;
9875
9876 impl ::fidl_next::Method for RemoveExtendedAttribute {
9877 const ORDINAL: u64 = 8794297771444732717;
9878 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9879 ::fidl_next::protocol::Flexibility::Strict;
9880
9881 type Protocol = crate::Directory;
9882
9883 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
9884 }
9885
9886 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
9887 type Response = ::fidl_next::wire::Result<
9888 'static,
9889 crate::wire::NodeRemoveExtendedAttributeResponse,
9890 ::fidl_next::wire::fuchsia::Status,
9891 >;
9892 }
9893
9894 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
9895 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9896
9897 fn respond(response: ___R) -> Self::Output {
9898 ::core::result::Result::Ok(response)
9899 }
9900 }
9901
9902 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
9903 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9904
9905 fn respond_err(response: ___R) -> Self::Output {
9906 ::core::result::Result::Err(response)
9907 }
9908 }
9909
9910 pub struct Open;
9911
9912 impl ::fidl_next::Method for Open {
9913 const ORDINAL: u64 = 6236883748953765593;
9914 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9915 ::fidl_next::protocol::Flexibility::Flexible;
9916
9917 type Protocol = crate::Directory;
9918
9919 type Request = crate::wire::OpenableOpenRequest<'static>;
9920 }
9921
9922 pub struct DeprecatedOpen;
9923
9924 impl ::fidl_next::Method for DeprecatedOpen {
9925 const ORDINAL: u64 = 3193127272456937152;
9926 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9927 ::fidl_next::protocol::Flexibility::Flexible;
9928
9929 type Protocol = crate::Directory;
9930
9931 type Request = crate::wire::DirectoryDeprecatedOpenRequest<'static>;
9932 }
9933
9934 pub struct ReadDirents;
9935
9936 impl ::fidl_next::Method for ReadDirents {
9937 const ORDINAL: u64 = 3855785432100874762;
9938 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9939 ::fidl_next::protocol::Flexibility::Strict;
9940
9941 type Protocol = crate::Directory;
9942
9943 type Request = crate::wire::DirectoryReadDirentsRequest;
9944 }
9945
9946 impl ::fidl_next::TwoWayMethod for ReadDirents {
9947 type Response =
9948 ::fidl_next::wire::Strict<crate::wire::DirectoryReadDirentsResponse<'static>>;
9949 }
9950
9951 impl<___R> ::fidl_next::Respond<___R> for ReadDirents {
9952 type Output = ::fidl_next::Strict<___R>;
9953
9954 fn respond(response: ___R) -> Self::Output {
9955 ::fidl_next::Strict(response)
9956 }
9957 }
9958
9959 pub struct Rewind;
9960
9961 impl ::fidl_next::Method for Rewind {
9962 const ORDINAL: u64 = 1635123508515392625;
9963 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9964 ::fidl_next::protocol::Flexibility::Strict;
9965
9966 type Protocol = crate::Directory;
9967
9968 type Request = ::fidl_next::wire::EmptyMessageBody;
9969 }
9970
9971 impl ::fidl_next::TwoWayMethod for Rewind {
9972 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryRewindResponse>;
9973 }
9974
9975 impl<___R> ::fidl_next::Respond<___R> for Rewind {
9976 type Output = ::fidl_next::Strict<crate::generic::DirectoryRewindResponse<___R>>;
9977
9978 fn respond(response: ___R) -> Self::Output {
9979 ::fidl_next::Strict(crate::generic::DirectoryRewindResponse { s: response })
9980 }
9981 }
9982
9983 pub struct DeprecatedGetToken;
9984
9985 impl ::fidl_next::Method for DeprecatedGetToken {
9986 const ORDINAL: u64 = 2787337947777369685;
9987 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9988 ::fidl_next::protocol::Flexibility::Strict;
9989
9990 type Protocol = crate::Directory;
9991
9992 type Request = ::fidl_next::wire::EmptyMessageBody;
9993 }
9994
9995 impl ::fidl_next::TwoWayMethod for DeprecatedGetToken {
9996 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryDeprecatedGetTokenResponse>;
9997 }
9998
9999 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetToken {
10000 type Output = ::fidl_next::Strict<___R>;
10001
10002 fn respond(response: ___R) -> Self::Output {
10003 ::fidl_next::Strict(response)
10004 }
10005 }
10006
10007 pub struct Link;
10008
10009 impl ::fidl_next::Method for Link {
10010 const ORDINAL: u64 = 8360374984291987687;
10011 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10012 ::fidl_next::protocol::Flexibility::Strict;
10013
10014 type Protocol = crate::Directory;
10015
10016 type Request = crate::wire::DirectoryLinkRequest<'static>;
10017 }
10018
10019 impl ::fidl_next::TwoWayMethod for Link {
10020 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryLinkResponse>;
10021 }
10022
10023 impl<___R> ::fidl_next::Respond<___R> for Link {
10024 type Output = ::fidl_next::Strict<crate::generic::DirectoryLinkResponse<___R>>;
10025
10026 fn respond(response: ___R) -> Self::Output {
10027 ::fidl_next::Strict(crate::generic::DirectoryLinkResponse { s: response })
10028 }
10029 }
10030
10031 pub struct Unlink;
10032
10033 impl ::fidl_next::Method for Unlink {
10034 const ORDINAL: u64 = 8433556716759383021;
10035 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10036 ::fidl_next::protocol::Flexibility::Strict;
10037
10038 type Protocol = crate::Directory;
10039
10040 type Request = crate::wire::DirectoryUnlinkRequest<'static>;
10041 }
10042
10043 impl ::fidl_next::TwoWayMethod for Unlink {
10044 type Response = ::fidl_next::wire::Result<
10045 'static,
10046 crate::wire::DirectoryUnlinkResponse,
10047 ::fidl_next::wire::fuchsia::Status,
10048 >;
10049 }
10050
10051 impl<___R> ::fidl_next::Respond<___R> for Unlink {
10052 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10053
10054 fn respond(response: ___R) -> Self::Output {
10055 ::core::result::Result::Ok(response)
10056 }
10057 }
10058
10059 impl<___R> ::fidl_next::RespondErr<___R> for Unlink {
10060 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10061
10062 fn respond_err(response: ___R) -> Self::Output {
10063 ::core::result::Result::Err(response)
10064 }
10065 }
10066
10067 pub struct Rename;
10068
10069 impl ::fidl_next::Method for Rename {
10070 const ORDINAL: u64 = 8097726607824333022;
10071 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10072 ::fidl_next::protocol::Flexibility::Strict;
10073
10074 type Protocol = crate::Directory;
10075
10076 type Request = crate::wire::DirectoryRenameRequest<'static>;
10077 }
10078
10079 impl ::fidl_next::TwoWayMethod for Rename {
10080 type Response = ::fidl_next::wire::Result<
10081 'static,
10082 crate::wire::DirectoryRenameResponse,
10083 ::fidl_next::wire::fuchsia::Status,
10084 >;
10085 }
10086
10087 impl<___R> ::fidl_next::Respond<___R> for Rename {
10088 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10089
10090 fn respond(response: ___R) -> Self::Output {
10091 ::core::result::Result::Ok(response)
10092 }
10093 }
10094
10095 impl<___R> ::fidl_next::RespondErr<___R> for Rename {
10096 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10097
10098 fn respond_err(response: ___R) -> Self::Output {
10099 ::core::result::Result::Err(response)
10100 }
10101 }
10102
10103 pub struct CreateSymlink;
10104
10105 impl ::fidl_next::Method for CreateSymlink {
10106 const ORDINAL: u64 = 2435901052462315657;
10107 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10108 ::fidl_next::protocol::Flexibility::Strict;
10109
10110 type Protocol = crate::Directory;
10111
10112 type Request = crate::wire::DirectoryCreateSymlinkRequest<'static>;
10113 }
10114
10115 impl ::fidl_next::TwoWayMethod for CreateSymlink {
10116 type Response = ::fidl_next::wire::Result<
10117 'static,
10118 crate::wire::DirectoryCreateSymlinkResponse,
10119 ::fidl_next::wire::fuchsia::Status,
10120 >;
10121 }
10122
10123 impl<___R> ::fidl_next::Respond<___R> for CreateSymlink {
10124 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10125
10126 fn respond(response: ___R) -> Self::Output {
10127 ::core::result::Result::Ok(response)
10128 }
10129 }
10130
10131 impl<___R> ::fidl_next::RespondErr<___R> for CreateSymlink {
10132 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10133
10134 fn respond_err(response: ___R) -> Self::Output {
10135 ::core::result::Result::Err(response)
10136 }
10137 }
10138
10139 pub struct Watch;
10140
10141 impl ::fidl_next::Method for Watch {
10142 const ORDINAL: u64 = 6275512344170098065;
10143 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10144 ::fidl_next::protocol::Flexibility::Strict;
10145
10146 type Protocol = crate::Directory;
10147
10148 type Request = crate::wire::DirectoryWatchRequest;
10149 }
10150
10151 impl ::fidl_next::TwoWayMethod for Watch {
10152 type Response = ::fidl_next::wire::Strict<crate::wire::DirectoryWatchResponse>;
10153 }
10154
10155 impl<___R> ::fidl_next::Respond<___R> for Watch {
10156 type Output = ::fidl_next::Strict<crate::generic::DirectoryWatchResponse<___R>>;
10157
10158 fn respond(response: ___R) -> Self::Output {
10159 ::fidl_next::Strict(crate::generic::DirectoryWatchResponse { s: response })
10160 }
10161 }
10162
10163 mod ___detail {
10164 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Directory
10165 where
10166 ___T: ::fidl_next::Transport,
10167 {
10168 type Client = DirectoryClient<___T>;
10169 type Server = DirectoryServer<___T>;
10170 }
10171
10172 #[repr(transparent)]
10174 pub struct DirectoryClient<___T: ::fidl_next::Transport> {
10175 #[allow(dead_code)]
10176 client: ::fidl_next::protocol::Client<___T>,
10177 }
10178
10179 impl<___T> DirectoryClient<___T>
10180 where
10181 ___T: ::fidl_next::Transport,
10182 {
10183 #[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"]
10184 pub fn advisory_lock(
10185 &self,
10186
10187 request: impl ::fidl_next::Encode<
10188 crate::wire::AdvisoryLockRequest<'static>,
10189 <___T as ::fidl_next::Transport>::SendBuffer,
10190 >,
10191 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
10192 where
10193 <___T as ::fidl_next::Transport>::SendBuffer:
10194 ::fidl_next::encoder::InternalHandleEncoder,
10195 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10196 {
10197 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
10198 request,
10199 })
10200 }
10201
10202 #[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"]
10203 pub fn advisory_lock_with<___R>(
10204 &self,
10205 request: ___R,
10206 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
10207 where
10208 ___R: ::fidl_next::Encode<
10209 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
10210 <___T as ::fidl_next::Transport>::SendBuffer,
10211 >,
10212 {
10213 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10214 7992130864415541162,
10215 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
10216 request,
10217 ))
10218 }
10219
10220 pub fn clone(
10221 &self,
10222
10223 request: impl ::fidl_next::Encode<
10224 ::fidl_next::ServerEnd<
10225 ::fidl_next_fuchsia_unknown::Cloneable,
10226 ::fidl_next::wire::fuchsia::Channel,
10227 >,
10228 <___T as ::fidl_next::Transport>::SendBuffer,
10229 >,
10230 ) -> ::fidl_next::SendFuture<'_, ___T>
10231 where
10232 <___T as ::fidl_next::Transport>::SendBuffer:
10233 ::fidl_next::encoder::InternalHandleEncoder,
10234 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10235 {
10236 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
10237 request,
10238 })
10239 }
10240
10241 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10242 where
10243 ___R: ::fidl_next::Encode<
10244 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
10245 <___T as ::fidl_next::Transport>::SendBuffer,
10246 >,
10247 {
10248 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10249 2366825959783828089,
10250 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
10251 request,
10252 ))
10253 }
10254
10255 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
10256 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
10257 ::fidl_next::TwoWayFuture::from_untyped(
10258 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10259 6540867515453498750,
10260 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
10261 (),
10262 ),
10263 )
10264 }
10265
10266 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
10267 ::fidl_next::TwoWayFuture::from_untyped(
10268 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10269 2763219980499352582,
10270 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
10271 (),
10272 ),
10273 )
10274 }
10275
10276 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
10277 pub fn deprecated_get_attr(
10278 &self,
10279 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
10280 ::fidl_next::TwoWayFuture::from_untyped(
10281 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10282 8689798978500614909,
10283 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
10284 (),
10285 ),
10286 )
10287 }
10288
10289 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
10290 pub fn deprecated_set_attr(
10291 &self,
10292
10293 flags: impl ::fidl_next::Encode<
10294 crate::wire::NodeAttributeFlags,
10295 <___T as ::fidl_next::Transport>::SendBuffer,
10296 >,
10297
10298 attributes: impl ::fidl_next::Encode<
10299 crate::wire::NodeAttributes,
10300 <___T as ::fidl_next::Transport>::SendBuffer,
10301 >,
10302 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
10303 where
10304 <___T as ::fidl_next::Transport>::SendBuffer:
10305 ::fidl_next::encoder::InternalHandleEncoder,
10306 {
10307 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
10308 flags,
10309
10310 attributes,
10311 })
10312 }
10313
10314 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
10315 pub fn deprecated_set_attr_with<___R>(
10316 &self,
10317 request: ___R,
10318 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
10319 where
10320 ___R: ::fidl_next::Encode<
10321 crate::wire::NodeDeprecatedSetAttrRequest,
10322 <___T as ::fidl_next::Transport>::SendBuffer,
10323 >,
10324 {
10325 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10326 4721673413776871238,
10327 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
10328 request,
10329 ))
10330 }
10331
10332 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
10333 pub fn deprecated_get_flags(
10334 &self,
10335 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
10336 ::fidl_next::TwoWayFuture::from_untyped(
10337 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10338 6595803110182632097,
10339 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
10340 (),
10341 ),
10342 )
10343 }
10344
10345 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
10346 pub fn deprecated_set_flags(
10347 &self,
10348
10349 flags: impl ::fidl_next::Encode<
10350 crate::wire::OpenFlags,
10351 <___T as ::fidl_next::Transport>::SendBuffer,
10352 >,
10353 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
10354 where
10355 <___T as ::fidl_next::Transport>::SendBuffer:
10356 ::fidl_next::encoder::InternalHandleEncoder,
10357 {
10358 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
10359 flags,
10360 })
10361 }
10362
10363 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
10364 pub fn deprecated_set_flags_with<___R>(
10365 &self,
10366 request: ___R,
10367 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
10368 where
10369 ___R: ::fidl_next::Encode<
10370 crate::wire::NodeDeprecatedSetFlagsRequest,
10371 <___T as ::fidl_next::Transport>::SendBuffer,
10372 >,
10373 {
10374 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10375 5950864159036794675,
10376 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
10377 request,
10378 ))
10379 }
10380
10381 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
10382 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
10383 ::fidl_next::TwoWayFuture::from_untyped(
10384 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10385 105530239381466147,
10386 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
10387 (),
10388 ),
10389 )
10390 }
10391
10392 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
10393 pub fn set_flags(
10394 &self,
10395
10396 flags: impl ::fidl_next::Encode<
10397 crate::wire::Flags,
10398 <___T as ::fidl_next::Transport>::SendBuffer,
10399 >,
10400 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
10401 where
10402 <___T as ::fidl_next::Transport>::SendBuffer:
10403 ::fidl_next::encoder::InternalHandleEncoder,
10404 {
10405 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
10406 }
10407
10408 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
10409 pub fn set_flags_with<___R>(
10410 &self,
10411 request: ___R,
10412 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
10413 where
10414 ___R: ::fidl_next::Encode<
10415 crate::wire::NodeSetFlagsRequest,
10416 <___T as ::fidl_next::Transport>::SendBuffer,
10417 >,
10418 {
10419 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10420 6172186066099445416,
10421 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
10422 request,
10423 ))
10424 }
10425
10426 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
10427 pub fn query_filesystem(
10428 &self,
10429 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
10430 ::fidl_next::TwoWayFuture::from_untyped(
10431 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10432 8013111122914313744,
10433 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
10434 (),
10435 ),
10436 )
10437 }
10438
10439 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
10440 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
10441 ::fidl_next::TwoWayFuture::from_untyped(
10442 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10443 5788516050773961964,
10444 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
10445 (),
10446 ),
10447 )
10448 }
10449
10450 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
10451 pub fn get_attributes(
10452 &self,
10453
10454 query: impl ::fidl_next::Encode<
10455 crate::wire::NodeAttributesQuery,
10456 <___T as ::fidl_next::Transport>::SendBuffer,
10457 >,
10458 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
10459 where
10460 <___T as ::fidl_next::Transport>::SendBuffer:
10461 ::fidl_next::encoder::InternalHandleEncoder,
10462 {
10463 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
10464 }
10465
10466 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
10467 pub fn get_attributes_with<___R>(
10468 &self,
10469 request: ___R,
10470 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
10471 where
10472 ___R: ::fidl_next::Encode<
10473 crate::wire::NodeGetAttributesRequest,
10474 <___T as ::fidl_next::Transport>::SendBuffer,
10475 >,
10476 {
10477 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10478 4414537700416816443,
10479 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
10480 request,
10481 ))
10482 }
10483
10484 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
10485 pub fn update_attributes_with<___R>(
10486 &self,
10487 request: ___R,
10488 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
10489 where
10490 ___R: ::fidl_next::Encode<
10491 crate::wire::MutableNodeAttributes<'static>,
10492 <___T as ::fidl_next::Transport>::SendBuffer,
10493 >,
10494 {
10495 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10496 3677402239314018056,
10497 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
10498 request,
10499 ))
10500 }
10501
10502 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
10503 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
10504 ::fidl_next::TwoWayFuture::from_untyped(
10505 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10506 3196473584242777161,
10507 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
10508 (),
10509 ),
10510 )
10511 }
10512
10513 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
10514 pub fn list_extended_attributes(
10515 &self,
10516
10517 iterator: impl ::fidl_next::Encode<
10518 ::fidl_next::ServerEnd<
10519 crate::ExtendedAttributeIterator,
10520 ::fidl_next::wire::fuchsia::Channel,
10521 >,
10522 <___T as ::fidl_next::Transport>::SendBuffer,
10523 >,
10524 ) -> ::fidl_next::SendFuture<'_, ___T>
10525 where
10526 <___T as ::fidl_next::Transport>::SendBuffer:
10527 ::fidl_next::encoder::InternalHandleEncoder,
10528 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10529 {
10530 self.list_extended_attributes_with(
10531 crate::generic::NodeListExtendedAttributesRequest { iterator },
10532 )
10533 }
10534
10535 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
10536 pub fn list_extended_attributes_with<___R>(
10537 &self,
10538 request: ___R,
10539 ) -> ::fidl_next::SendFuture<'_, ___T>
10540 where
10541 ___R: ::fidl_next::Encode<
10542 crate::wire::NodeListExtendedAttributesRequest,
10543 <___T as ::fidl_next::Transport>::SendBuffer,
10544 >,
10545 {
10546 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10547 5431626189872037072,
10548 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
10549 request,
10550 ))
10551 }
10552
10553 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
10554 pub fn get_extended_attribute(
10555 &self,
10556
10557 name: impl ::fidl_next::Encode<
10558 ::fidl_next::wire::Vector<'static, u8>,
10559 <___T as ::fidl_next::Transport>::SendBuffer,
10560 >,
10561 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
10562 where
10563 <___T as ::fidl_next::Transport>::SendBuffer:
10564 ::fidl_next::encoder::InternalHandleEncoder,
10565 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10566 {
10567 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
10568 name,
10569 })
10570 }
10571
10572 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
10573 pub fn get_extended_attribute_with<___R>(
10574 &self,
10575 request: ___R,
10576 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
10577 where
10578 ___R: ::fidl_next::Encode<
10579 crate::wire::NodeGetExtendedAttributeRequest<'static>,
10580 <___T as ::fidl_next::Transport>::SendBuffer,
10581 >,
10582 {
10583 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10584 5043930208506967771,
10585 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10586 request,
10587 ))
10588 }
10589
10590 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
10591 pub fn set_extended_attribute(
10592 &self,
10593
10594 name: impl ::fidl_next::Encode<
10595 ::fidl_next::wire::Vector<'static, u8>,
10596 <___T as ::fidl_next::Transport>::SendBuffer,
10597 >,
10598
10599 value: impl ::fidl_next::Encode<
10600 crate::wire::ExtendedAttributeValue<'static>,
10601 <___T as ::fidl_next::Transport>::SendBuffer,
10602 >,
10603
10604 mode: impl ::fidl_next::Encode<
10605 crate::wire::SetExtendedAttributeMode,
10606 <___T as ::fidl_next::Transport>::SendBuffer,
10607 >,
10608 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10609 where
10610 <___T as ::fidl_next::Transport>::SendBuffer:
10611 ::fidl_next::encoder::InternalHandleEncoder,
10612 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10613 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10614 {
10615 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
10616 name,
10617
10618 value,
10619
10620 mode,
10621 })
10622 }
10623
10624 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
10625 pub fn set_extended_attribute_with<___R>(
10626 &self,
10627 request: ___R,
10628 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
10629 where
10630 ___R: ::fidl_next::Encode<
10631 crate::wire::NodeSetExtendedAttributeRequest<'static>,
10632 <___T as ::fidl_next::Transport>::SendBuffer,
10633 >,
10634 {
10635 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10636 5374223046099989052,
10637 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10638 request,
10639 ))
10640 }
10641
10642 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
10643 pub fn remove_extended_attribute(
10644 &self,
10645
10646 name: impl ::fidl_next::Encode<
10647 ::fidl_next::wire::Vector<'static, u8>,
10648 <___T as ::fidl_next::Transport>::SendBuffer,
10649 >,
10650 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10651 where
10652 <___T as ::fidl_next::Transport>::SendBuffer:
10653 ::fidl_next::encoder::InternalHandleEncoder,
10654 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10655 {
10656 self.remove_extended_attribute_with(
10657 crate::generic::NodeRemoveExtendedAttributeRequest { name },
10658 )
10659 }
10660
10661 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
10662 pub fn remove_extended_attribute_with<___R>(
10663 &self,
10664 request: ___R,
10665 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
10666 where
10667 ___R: ::fidl_next::Encode<
10668 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
10669 <___T as ::fidl_next::Transport>::SendBuffer,
10670 >,
10671 {
10672 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10673 8794297771444732717,
10674 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
10675 request,
10676 ))
10677 }
10678
10679 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
10680 pub fn open(
10681 &self,
10682
10683 path: impl ::fidl_next::Encode<
10684 ::fidl_next::wire::String<'static>,
10685 <___T as ::fidl_next::Transport>::SendBuffer,
10686 >,
10687
10688 flags: impl ::fidl_next::Encode<
10689 crate::wire::Flags,
10690 <___T as ::fidl_next::Transport>::SendBuffer,
10691 >,
10692
10693 options: impl ::fidl_next::Encode<
10694 crate::wire::Options<'static>,
10695 <___T as ::fidl_next::Transport>::SendBuffer,
10696 >,
10697
10698 object: impl ::fidl_next::Encode<
10699 ::fidl_next::wire::fuchsia::Channel,
10700 <___T as ::fidl_next::Transport>::SendBuffer,
10701 >,
10702 ) -> ::fidl_next::SendFuture<'_, ___T>
10703 where
10704 <___T as ::fidl_next::Transport>::SendBuffer:
10705 ::fidl_next::encoder::InternalHandleEncoder,
10706 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10707 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10708 {
10709 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
10710 }
10711
10712 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
10713 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
10714 where
10715 ___R: ::fidl_next::Encode<
10716 crate::wire::OpenableOpenRequest<'static>,
10717 <___T as ::fidl_next::Transport>::SendBuffer,
10718 >,
10719 {
10720 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10721 6236883748953765593,
10722 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
10723 request,
10724 ))
10725 }
10726
10727 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10728 pub fn deprecated_open(
10729 &self,
10730
10731 flags: impl ::fidl_next::Encode<
10732 crate::wire::OpenFlags,
10733 <___T as ::fidl_next::Transport>::SendBuffer,
10734 >,
10735
10736 mode: impl ::fidl_next::Encode<
10737 crate::wire::ModeType,
10738 <___T as ::fidl_next::Transport>::SendBuffer,
10739 >,
10740
10741 path: impl ::fidl_next::Encode<
10742 ::fidl_next::wire::String<'static>,
10743 <___T as ::fidl_next::Transport>::SendBuffer,
10744 >,
10745
10746 object: impl ::fidl_next::Encode<
10747 ::fidl_next::ServerEnd<crate::Node, ::fidl_next::wire::fuchsia::Channel>,
10748 <___T as ::fidl_next::Transport>::SendBuffer,
10749 >,
10750 ) -> ::fidl_next::SendFuture<'_, ___T>
10751 where
10752 <___T as ::fidl_next::Transport>::SendBuffer:
10753 ::fidl_next::encoder::InternalHandleEncoder,
10754 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10755 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10756 {
10757 self.deprecated_open_with(crate::generic::DirectoryDeprecatedOpenRequest {
10758 flags,
10759
10760 mode,
10761
10762 path,
10763
10764 object,
10765 })
10766 }
10767
10768 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
10769 pub fn deprecated_open_with<___R>(
10770 &self,
10771 request: ___R,
10772 ) -> ::fidl_next::SendFuture<'_, ___T>
10773 where
10774 ___R: ::fidl_next::Encode<
10775 crate::wire::DirectoryDeprecatedOpenRequest<'static>,
10776 <___T as ::fidl_next::Transport>::SendBuffer,
10777 >,
10778 {
10779 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
10780 3193127272456937152,
10781 <super::DeprecatedOpen as ::fidl_next::Method>::FLEXIBILITY,
10782 request,
10783 ))
10784 }
10785
10786 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10787 pub fn read_dirents(
10788 &self,
10789
10790 max_bytes: impl ::fidl_next::Encode<
10791 ::fidl_next::wire::Uint64,
10792 <___T as ::fidl_next::Transport>::SendBuffer,
10793 >,
10794 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10795 where
10796 <___T as ::fidl_next::Transport>::SendBuffer:
10797 ::fidl_next::encoder::InternalHandleEncoder,
10798 {
10799 self.read_dirents_with(crate::generic::DirectoryReadDirentsRequest { max_bytes })
10800 }
10801
10802 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10803 pub fn read_dirents_with<___R>(
10804 &self,
10805 request: ___R,
10806 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadDirents, ___T>
10807 where
10808 ___R: ::fidl_next::Encode<
10809 crate::wire::DirectoryReadDirentsRequest,
10810 <___T as ::fidl_next::Transport>::SendBuffer,
10811 >,
10812 {
10813 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10814 3855785432100874762,
10815 <super::ReadDirents as ::fidl_next::Method>::FLEXIBILITY,
10816 request,
10817 ))
10818 }
10819
10820 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
10821 pub fn rewind(&self) -> ::fidl_next::TwoWayFuture<'_, super::Rewind, ___T> {
10822 ::fidl_next::TwoWayFuture::from_untyped(
10823 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10824 1635123508515392625,
10825 <super::Rewind as ::fidl_next::Method>::FLEXIBILITY,
10826 (),
10827 ),
10828 )
10829 }
10830
10831 #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
10832 pub fn deprecated_get_token(
10833 &self,
10834 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetToken, ___T> {
10835 ::fidl_next::TwoWayFuture::from_untyped(
10836 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10837 2787337947777369685,
10838 <super::DeprecatedGetToken as ::fidl_next::Method>::FLEXIBILITY,
10839 (),
10840 ),
10841 )
10842 }
10843
10844 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
10845 pub fn link(
10846 &self,
10847
10848 src: impl ::fidl_next::Encode<
10849 ::fidl_next::wire::String<'static>,
10850 <___T as ::fidl_next::Transport>::SendBuffer,
10851 >,
10852
10853 dst_parent_token: impl ::fidl_next::Encode<
10854 ::fidl_next::wire::fuchsia::NullableHandle,
10855 <___T as ::fidl_next::Transport>::SendBuffer,
10856 >,
10857
10858 dst: impl ::fidl_next::Encode<
10859 ::fidl_next::wire::String<'static>,
10860 <___T as ::fidl_next::Transport>::SendBuffer,
10861 >,
10862 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10863 where
10864 <___T as ::fidl_next::Transport>::SendBuffer:
10865 ::fidl_next::encoder::InternalHandleEncoder,
10866 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10867 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10868 {
10869 self.link_with(crate::generic::DirectoryLinkRequest { src, dst_parent_token, dst })
10870 }
10871
10872 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
10873 pub fn link_with<___R>(
10874 &self,
10875 request: ___R,
10876 ) -> ::fidl_next::TwoWayFuture<'_, super::Link, ___T>
10877 where
10878 ___R: ::fidl_next::Encode<
10879 crate::wire::DirectoryLinkRequest<'static>,
10880 <___T as ::fidl_next::Transport>::SendBuffer,
10881 >,
10882 {
10883 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10884 8360374984291987687,
10885 <super::Link as ::fidl_next::Method>::FLEXIBILITY,
10886 request,
10887 ))
10888 }
10889
10890 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
10891 pub fn unlink(
10892 &self,
10893
10894 name: impl ::fidl_next::Encode<
10895 ::fidl_next::wire::String<'static>,
10896 <___T as ::fidl_next::Transport>::SendBuffer,
10897 >,
10898
10899 options: impl ::fidl_next::Encode<
10900 crate::wire::UnlinkOptions<'static>,
10901 <___T as ::fidl_next::Transport>::SendBuffer,
10902 >,
10903 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10904 where
10905 <___T as ::fidl_next::Transport>::SendBuffer:
10906 ::fidl_next::encoder::InternalHandleEncoder,
10907 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10908 {
10909 self.unlink_with(crate::generic::DirectoryUnlinkRequest { name, options })
10910 }
10911
10912 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
10913 pub fn unlink_with<___R>(
10914 &self,
10915 request: ___R,
10916 ) -> ::fidl_next::TwoWayFuture<'_, super::Unlink, ___T>
10917 where
10918 ___R: ::fidl_next::Encode<
10919 crate::wire::DirectoryUnlinkRequest<'static>,
10920 <___T as ::fidl_next::Transport>::SendBuffer,
10921 >,
10922 {
10923 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10924 8433556716759383021,
10925 <super::Unlink as ::fidl_next::Method>::FLEXIBILITY,
10926 request,
10927 ))
10928 }
10929
10930 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
10931 pub fn rename(
10932 &self,
10933
10934 src: impl ::fidl_next::Encode<
10935 ::fidl_next::wire::String<'static>,
10936 <___T as ::fidl_next::Transport>::SendBuffer,
10937 >,
10938
10939 dst_parent_token: impl ::fidl_next::Encode<
10940 ::fidl_next::wire::fuchsia::Event,
10941 <___T as ::fidl_next::Transport>::SendBuffer,
10942 >,
10943
10944 dst: impl ::fidl_next::Encode<
10945 ::fidl_next::wire::String<'static>,
10946 <___T as ::fidl_next::Transport>::SendBuffer,
10947 >,
10948 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10949 where
10950 <___T as ::fidl_next::Transport>::SendBuffer:
10951 ::fidl_next::encoder::InternalHandleEncoder,
10952 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10953 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10954 {
10955 self.rename_with(crate::generic::DirectoryRenameRequest {
10956 src,
10957
10958 dst_parent_token,
10959
10960 dst,
10961 })
10962 }
10963
10964 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
10965 pub fn rename_with<___R>(
10966 &self,
10967 request: ___R,
10968 ) -> ::fidl_next::TwoWayFuture<'_, super::Rename, ___T>
10969 where
10970 ___R: ::fidl_next::Encode<
10971 crate::wire::DirectoryRenameRequest<'static>,
10972 <___T as ::fidl_next::Transport>::SendBuffer,
10973 >,
10974 {
10975 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10976 8097726607824333022,
10977 <super::Rename as ::fidl_next::Method>::FLEXIBILITY,
10978 request,
10979 ))
10980 }
10981
10982 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
10983 pub fn create_symlink(
10984 &self,
10985
10986 name: impl ::fidl_next::Encode<
10987 ::fidl_next::wire::String<'static>,
10988 <___T as ::fidl_next::Transport>::SendBuffer,
10989 >,
10990
10991 target: impl ::fidl_next::Encode<
10992 ::fidl_next::wire::Vector<'static, u8>,
10993 <___T as ::fidl_next::Transport>::SendBuffer,
10994 >,
10995
10996 connection: impl ::fidl_next::Encode<
10997 ::fidl_next::ServerEnd<
10998 crate::Symlink,
10999 ::fidl_next::wire::fuchsia::OptionalChannel,
11000 >,
11001 <___T as ::fidl_next::Transport>::SendBuffer,
11002 >,
11003 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
11004 where
11005 <___T as ::fidl_next::Transport>::SendBuffer:
11006 ::fidl_next::encoder::InternalHandleEncoder,
11007 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11008 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11009 {
11010 self.create_symlink_with(crate::generic::DirectoryCreateSymlinkRequest {
11011 name,
11012
11013 target,
11014
11015 connection,
11016 })
11017 }
11018
11019 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
11020 pub fn create_symlink_with<___R>(
11021 &self,
11022 request: ___R,
11023 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateSymlink, ___T>
11024 where
11025 ___R: ::fidl_next::Encode<
11026 crate::wire::DirectoryCreateSymlinkRequest<'static>,
11027 <___T as ::fidl_next::Transport>::SendBuffer,
11028 >,
11029 {
11030 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11031 2435901052462315657,
11032 <super::CreateSymlink as ::fidl_next::Method>::FLEXIBILITY,
11033 request,
11034 ))
11035 }
11036
11037 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11038 pub fn watch(
11039 &self,
11040
11041 mask: impl ::fidl_next::Encode<
11042 crate::wire::WatchMask,
11043 <___T as ::fidl_next::Transport>::SendBuffer,
11044 >,
11045
11046 options: impl ::fidl_next::Encode<
11047 ::fidl_next::wire::Uint32,
11048 <___T as ::fidl_next::Transport>::SendBuffer,
11049 >,
11050
11051 watcher: impl ::fidl_next::Encode<
11052 ::fidl_next::ServerEnd<
11053 crate::DirectoryWatcher,
11054 ::fidl_next::wire::fuchsia::Channel,
11055 >,
11056 <___T as ::fidl_next::Transport>::SendBuffer,
11057 >,
11058 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
11059 where
11060 <___T as ::fidl_next::Transport>::SendBuffer:
11061 ::fidl_next::encoder::InternalHandleEncoder,
11062 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11063 {
11064 self.watch_with(crate::generic::DirectoryWatchRequest { mask, options, watcher })
11065 }
11066
11067 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11068 pub fn watch_with<___R>(
11069 &self,
11070 request: ___R,
11071 ) -> ::fidl_next::TwoWayFuture<'_, super::Watch, ___T>
11072 where
11073 ___R: ::fidl_next::Encode<
11074 crate::wire::DirectoryWatchRequest,
11075 <___T as ::fidl_next::Transport>::SendBuffer,
11076 >,
11077 {
11078 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11079 6275512344170098065,
11080 <super::Watch as ::fidl_next::Method>::FLEXIBILITY,
11081 request,
11082 ))
11083 }
11084 }
11085
11086 #[repr(transparent)]
11088 pub struct DirectoryServer<___T: ::fidl_next::Transport> {
11089 server: ::fidl_next::protocol::Server<___T>,
11090 }
11091
11092 impl<___T> DirectoryServer<___T>
11093 where
11094 ___T: ::fidl_next::Transport,
11095 {
11096 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
11097 pub fn on_open(
11098 &self,
11099
11100 s: impl ::fidl_next::Encode<
11101 ::fidl_next::wire::fuchsia::StatusResult,
11102 <___T as ::fidl_next::Transport>::SendBuffer,
11103 >,
11104
11105 info: impl ::fidl_next::Encode<
11106 crate::wire_optional::NodeInfoDeprecated<'static>,
11107 <___T as ::fidl_next::Transport>::SendBuffer,
11108 >,
11109 ) -> ::fidl_next::SendFuture<'_, ___T>
11110 where
11111 <___T as ::fidl_next::Transport>::SendBuffer:
11112 ::fidl_next::encoder::InternalHandleEncoder,
11113 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11114 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11115 {
11116 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
11117 }
11118
11119 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
11120
11121 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
11122 where
11123 ___R: ::fidl_next::Encode<
11124 <super::OnOpen as ::fidl_next::Method>::Request,
11125 <___T as ::fidl_next::Transport>::SendBuffer,
11126 >,
11127 {
11128 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
11129 9207534335756671346,
11130 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
11131 request,
11132 ))
11133 }
11134
11135 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
11136
11137 pub fn on_representation_with<___R>(
11138 &self,
11139 request: ___R,
11140 ) -> ::fidl_next::SendFuture<'_, ___T>
11141 where
11142 ___R: ::fidl_next::Encode<
11143 <super::OnRepresentation as ::fidl_next::Method>::Request,
11144 <___T as ::fidl_next::Transport>::SendBuffer,
11145 >,
11146 {
11147 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
11148 6679970090861613324,
11149 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
11150 request,
11151 ))
11152 }
11153 }
11154 }
11155}
11156
11157#[diagnostic::on_unimplemented(
11158 note = "If {Self} implements the non-local DirectoryClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11159)]
11160
11161pub trait DirectoryLocalClientHandler<
11165 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11166 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11167>
11168{
11169 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
11170 fn on_open(
11171 &mut self,
11172
11173 request: ::fidl_next::Request<directory::OnOpen, ___T>,
11174 ) -> impl ::core::future::Future<Output = ()>;
11175
11176 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
11177 fn on_representation(
11178 &mut self,
11179
11180 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
11181 ) -> impl ::core::future::Future<Output = ()>;
11182
11183 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11184 ::core::future::ready(())
11185 }
11186}
11187
11188impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Directory
11189where
11190 ___H: DirectoryLocalClientHandler<___T>,
11191 ___T: ::fidl_next::Transport,
11192 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
11193 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11194 Constraint = (),
11195 >,
11196 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
11197 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11198 Constraint = (),
11199 >,
11200{
11201 async fn on_event(
11202 handler: &mut ___H,
11203 mut message: ::fidl_next::Message<___T>,
11204 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11205 match *message.header().ordinal {
11206 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11207 Ok(decoded) => {
11208 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
11209 Ok(())
11210 }
11211 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11212 ordinal: 9207534335756671346,
11213 error,
11214 }),
11215 },
11216
11217 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11218 Ok(decoded) => {
11219 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
11220 Ok(())
11221 }
11222 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11223 ordinal: 6679970090861613324,
11224 error,
11225 }),
11226 },
11227
11228 ordinal => {
11229 handler.on_unknown_interaction(ordinal).await;
11230 if ::core::matches!(
11231 message.header().flexibility(),
11232 ::fidl_next::protocol::Flexibility::Strict
11233 ) {
11234 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11235 } else {
11236 Ok(())
11237 }
11238 }
11239 }
11240 }
11241}
11242
11243#[diagnostic::on_unimplemented(
11244 note = "If {Self} implements the non-local DirectoryServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11245)]
11246
11247pub trait DirectoryLocalServerHandler<
11251 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11252 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11253>
11254{
11255 #[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"]
11256 fn advisory_lock(
11257 &mut self,
11258
11259 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
11260
11261 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
11262 ) -> impl ::core::future::Future<Output = ()>;
11263
11264 fn clone(
11265 &mut self,
11266
11267 request: ::fidl_next::Request<directory::Clone, ___T>,
11268 ) -> impl ::core::future::Future<Output = ()>;
11269
11270 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
11271 fn close(
11272 &mut self,
11273
11274 responder: ::fidl_next::Responder<directory::Close, ___T>,
11275 ) -> impl ::core::future::Future<Output = ()>;
11276
11277 fn query(
11278 &mut self,
11279
11280 responder: ::fidl_next::Responder<directory::Query, ___T>,
11281 ) -> impl ::core::future::Future<Output = ()>;
11282
11283 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11284 fn deprecated_get_attr(
11285 &mut self,
11286
11287 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
11288 ) -> impl ::core::future::Future<Output = ()>;
11289
11290 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
11291 fn deprecated_set_attr(
11292 &mut self,
11293
11294 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
11295
11296 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
11297 ) -> impl ::core::future::Future<Output = ()>;
11298
11299 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
11300 fn deprecated_get_flags(
11301 &mut self,
11302
11303 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
11304 ) -> impl ::core::future::Future<Output = ()>;
11305
11306 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
11307 fn deprecated_set_flags(
11308 &mut self,
11309
11310 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
11311
11312 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
11313 ) -> impl ::core::future::Future<Output = ()>;
11314
11315 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
11316 fn get_flags(
11317 &mut self,
11318
11319 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
11320 ) -> impl ::core::future::Future<Output = ()>;
11321
11322 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
11323 fn set_flags(
11324 &mut self,
11325
11326 request: ::fidl_next::Request<directory::SetFlags, ___T>,
11327
11328 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
11329 ) -> impl ::core::future::Future<Output = ()>;
11330
11331 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
11332 fn query_filesystem(
11333 &mut self,
11334
11335 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
11336 ) -> impl ::core::future::Future<Output = ()>;
11337
11338 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
11339 fn get_token(
11340 &mut self,
11341
11342 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
11343 ) -> impl ::core::future::Future<Output = ()>;
11344
11345 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
11346 fn get_attributes(
11347 &mut self,
11348
11349 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
11350
11351 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
11352 ) -> impl ::core::future::Future<Output = ()>;
11353
11354 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
11355 fn update_attributes(
11356 &mut self,
11357
11358 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
11359
11360 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
11361 ) -> impl ::core::future::Future<Output = ()>;
11362
11363 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
11364 fn sync(
11365 &mut self,
11366
11367 responder: ::fidl_next::Responder<directory::Sync, ___T>,
11368 ) -> impl ::core::future::Future<Output = ()>;
11369
11370 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
11371 fn list_extended_attributes(
11372 &mut self,
11373
11374 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
11375 ) -> impl ::core::future::Future<Output = ()>;
11376
11377 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
11378 fn get_extended_attribute(
11379 &mut self,
11380
11381 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
11382
11383 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
11384 ) -> impl ::core::future::Future<Output = ()>;
11385
11386 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
11387 fn set_extended_attribute(
11388 &mut self,
11389
11390 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
11391
11392 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
11393 ) -> impl ::core::future::Future<Output = ()>;
11394
11395 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
11396 fn remove_extended_attribute(
11397 &mut self,
11398
11399 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
11400
11401 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
11402 ) -> impl ::core::future::Future<Output = ()>;
11403
11404 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
11405 fn open(
11406 &mut self,
11407
11408 request: ::fidl_next::Request<directory::Open, ___T>,
11409 ) -> impl ::core::future::Future<Output = ()>;
11410
11411 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
11412 fn deprecated_open(
11413 &mut self,
11414
11415 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
11416 ) -> impl ::core::future::Future<Output = ()>;
11417
11418 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11419 fn read_dirents(
11420 &mut self,
11421
11422 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
11423
11424 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
11425 ) -> impl ::core::future::Future<Output = ()>;
11426
11427 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11428 fn rewind(
11429 &mut self,
11430
11431 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
11432 ) -> impl ::core::future::Future<Output = ()>;
11433
11434 #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
11435 fn deprecated_get_token(
11436 &mut self,
11437
11438 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
11439 ) -> impl ::core::future::Future<Output = ()>;
11440
11441 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
11442 fn link(
11443 &mut self,
11444
11445 request: ::fidl_next::Request<directory::Link, ___T>,
11446
11447 responder: ::fidl_next::Responder<directory::Link, ___T>,
11448 ) -> impl ::core::future::Future<Output = ()>;
11449
11450 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
11451 fn unlink(
11452 &mut self,
11453
11454 request: ::fidl_next::Request<directory::Unlink, ___T>,
11455
11456 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
11457 ) -> impl ::core::future::Future<Output = ()>;
11458
11459 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
11460 fn rename(
11461 &mut self,
11462
11463 request: ::fidl_next::Request<directory::Rename, ___T>,
11464
11465 responder: ::fidl_next::Responder<directory::Rename, ___T>,
11466 ) -> impl ::core::future::Future<Output = ()>;
11467
11468 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
11469 fn create_symlink(
11470 &mut self,
11471
11472 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
11473
11474 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
11475 ) -> impl ::core::future::Future<Output = ()>;
11476
11477 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
11478 fn watch(
11479 &mut self,
11480
11481 request: ::fidl_next::Request<directory::Watch, ___T>,
11482
11483 responder: ::fidl_next::Responder<directory::Watch, ___T>,
11484 ) -> impl ::core::future::Future<Output = ()>;
11485
11486 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
11487 ::core::future::ready(())
11488 }
11489}
11490
11491impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Directory
11492where
11493 ___H: DirectoryLocalServerHandler<___T>,
11494 ___T: ::fidl_next::Transport,
11495 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
11496 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11497 Constraint = (),
11498 >,
11499 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
11500 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11501 Constraint = (),
11502 >,
11503 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
11504 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11505 Constraint = (),
11506 >,
11507 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
11508 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11509 Constraint = (),
11510 >,
11511 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
11512 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11513 Constraint = (),
11514 >,
11515 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
11516 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11517 Constraint = (),
11518 >,
11519 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
11520 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11521 Constraint = (),
11522 >,
11523 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
11524 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11525 Constraint = (),
11526 >,
11527 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11528 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11529 Constraint = (),
11530 >,
11531 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11532 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11533 Constraint = (),
11534 >,
11535 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
11536 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11537 Constraint = (),
11538 >,
11539 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
11540 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11541 Constraint = (),
11542 >,
11543 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
11544 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11545 Constraint = (),
11546 >,
11547 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
11548 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11549 Constraint = (),
11550 >,
11551 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
11552 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11553 Constraint = (),
11554 >,
11555 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
11556 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11557 Constraint = (),
11558 >,
11559 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
11560 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11561 Constraint = (),
11562 >,
11563 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
11564 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11565 Constraint = (),
11566 >,
11567 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
11568 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11569 Constraint = (),
11570 >,
11571{
11572 async fn on_one_way(
11573 handler: &mut ___H,
11574 mut message: ::fidl_next::Message<___T>,
11575 ) -> ::core::result::Result<
11576 (),
11577 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11578 > {
11579 match *message.header().ordinal {
11580 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11581 Ok(decoded) => {
11582 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
11583 Ok(())
11584 }
11585 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11586 ordinal: 2366825959783828089,
11587 error,
11588 }),
11589 },
11590
11591 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11592 Ok(decoded) => {
11593 handler
11594 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
11595 .await;
11596 Ok(())
11597 }
11598 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11599 ordinal: 5431626189872037072,
11600 error,
11601 }),
11602 },
11603
11604 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11605 Ok(decoded) => {
11606 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
11607 Ok(())
11608 }
11609 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11610 ordinal: 6236883748953765593,
11611 error,
11612 }),
11613 },
11614
11615 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
11616 Ok(decoded) => {
11617 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
11618 Ok(())
11619 }
11620 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11621 ordinal: 3193127272456937152,
11622 error,
11623 }),
11624 },
11625
11626 ordinal => {
11627 handler.on_unknown_interaction(ordinal).await;
11628 if ::core::matches!(
11629 message.header().flexibility(),
11630 ::fidl_next::protocol::Flexibility::Strict
11631 ) {
11632 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11633 } else {
11634 Ok(())
11635 }
11636 }
11637 }
11638 }
11639
11640 async fn on_two_way(
11641 handler: &mut ___H,
11642 mut message: ::fidl_next::Message<___T>,
11643 responder: ::fidl_next::protocol::Responder<___T>,
11644 ) -> ::core::result::Result<
11645 (),
11646 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11647 > {
11648 match *message.header().ordinal {
11649 7992130864415541162 => {
11650 let responder = ::fidl_next::Responder::from_untyped(responder);
11651
11652 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11653 Ok(decoded) => {
11654 handler
11655 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
11656 .await;
11657 Ok(())
11658 }
11659 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11660 ordinal: 7992130864415541162,
11661 error,
11662 }),
11663 }
11664 }
11665
11666 6540867515453498750 => {
11667 let responder = ::fidl_next::Responder::from_untyped(responder);
11668
11669 handler.close(responder).await;
11670 Ok(())
11671 }
11672
11673 2763219980499352582 => {
11674 let responder = ::fidl_next::Responder::from_untyped(responder);
11675
11676 handler.query(responder).await;
11677 Ok(())
11678 }
11679
11680 8689798978500614909 => {
11681 let responder = ::fidl_next::Responder::from_untyped(responder);
11682
11683 handler.deprecated_get_attr(responder).await;
11684 Ok(())
11685 }
11686
11687 4721673413776871238 => {
11688 let responder = ::fidl_next::Responder::from_untyped(responder);
11689
11690 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11691 Ok(decoded) => {
11692 handler
11693 .deprecated_set_attr(
11694 ::fidl_next::Request::from_decoded(decoded),
11695 responder,
11696 )
11697 .await;
11698 Ok(())
11699 }
11700 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11701 ordinal: 4721673413776871238,
11702 error,
11703 }),
11704 }
11705 }
11706
11707 6595803110182632097 => {
11708 let responder = ::fidl_next::Responder::from_untyped(responder);
11709
11710 handler.deprecated_get_flags(responder).await;
11711 Ok(())
11712 }
11713
11714 5950864159036794675 => {
11715 let responder = ::fidl_next::Responder::from_untyped(responder);
11716
11717 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11718 Ok(decoded) => {
11719 handler
11720 .deprecated_set_flags(
11721 ::fidl_next::Request::from_decoded(decoded),
11722 responder,
11723 )
11724 .await;
11725 Ok(())
11726 }
11727 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11728 ordinal: 5950864159036794675,
11729 error,
11730 }),
11731 }
11732 }
11733
11734 105530239381466147 => {
11735 let responder = ::fidl_next::Responder::from_untyped(responder);
11736
11737 handler.get_flags(responder).await;
11738 Ok(())
11739 }
11740
11741 6172186066099445416 => {
11742 let responder = ::fidl_next::Responder::from_untyped(responder);
11743
11744 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11745 Ok(decoded) => {
11746 handler
11747 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
11748 .await;
11749 Ok(())
11750 }
11751 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11752 ordinal: 6172186066099445416,
11753 error,
11754 }),
11755 }
11756 }
11757
11758 8013111122914313744 => {
11759 let responder = ::fidl_next::Responder::from_untyped(responder);
11760
11761 handler.query_filesystem(responder).await;
11762 Ok(())
11763 }
11764
11765 5788516050773961964 => {
11766 let responder = ::fidl_next::Responder::from_untyped(responder);
11767
11768 handler.get_token(responder).await;
11769 Ok(())
11770 }
11771
11772 4414537700416816443 => {
11773 let responder = ::fidl_next::Responder::from_untyped(responder);
11774
11775 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11776 Ok(decoded) => {
11777 handler
11778 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
11779 .await;
11780 Ok(())
11781 }
11782 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11783 ordinal: 4414537700416816443,
11784 error,
11785 }),
11786 }
11787 }
11788
11789 3677402239314018056 => {
11790 let responder = ::fidl_next::Responder::from_untyped(responder);
11791
11792 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11793 Ok(decoded) => {
11794 handler
11795 .update_attributes(
11796 ::fidl_next::Request::from_decoded(decoded),
11797 responder,
11798 )
11799 .await;
11800 Ok(())
11801 }
11802 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11803 ordinal: 3677402239314018056,
11804 error,
11805 }),
11806 }
11807 }
11808
11809 3196473584242777161 => {
11810 let responder = ::fidl_next::Responder::from_untyped(responder);
11811
11812 handler.sync(responder).await;
11813 Ok(())
11814 }
11815
11816 5043930208506967771 => {
11817 let responder = ::fidl_next::Responder::from_untyped(responder);
11818
11819 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11820 Ok(decoded) => {
11821 handler
11822 .get_extended_attribute(
11823 ::fidl_next::Request::from_decoded(decoded),
11824 responder,
11825 )
11826 .await;
11827 Ok(())
11828 }
11829 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11830 ordinal: 5043930208506967771,
11831 error,
11832 }),
11833 }
11834 }
11835
11836 5374223046099989052 => {
11837 let responder = ::fidl_next::Responder::from_untyped(responder);
11838
11839 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11840 Ok(decoded) => {
11841 handler
11842 .set_extended_attribute(
11843 ::fidl_next::Request::from_decoded(decoded),
11844 responder,
11845 )
11846 .await;
11847 Ok(())
11848 }
11849 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11850 ordinal: 5374223046099989052,
11851 error,
11852 }),
11853 }
11854 }
11855
11856 8794297771444732717 => {
11857 let responder = ::fidl_next::Responder::from_untyped(responder);
11858
11859 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11860 Ok(decoded) => {
11861 handler
11862 .remove_extended_attribute(
11863 ::fidl_next::Request::from_decoded(decoded),
11864 responder,
11865 )
11866 .await;
11867 Ok(())
11868 }
11869 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11870 ordinal: 8794297771444732717,
11871 error,
11872 }),
11873 }
11874 }
11875
11876 3855785432100874762 => {
11877 let responder = ::fidl_next::Responder::from_untyped(responder);
11878
11879 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11880 Ok(decoded) => {
11881 handler
11882 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
11883 .await;
11884 Ok(())
11885 }
11886 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11887 ordinal: 3855785432100874762,
11888 error,
11889 }),
11890 }
11891 }
11892
11893 1635123508515392625 => {
11894 let responder = ::fidl_next::Responder::from_untyped(responder);
11895
11896 handler.rewind(responder).await;
11897 Ok(())
11898 }
11899
11900 2787337947777369685 => {
11901 let responder = ::fidl_next::Responder::from_untyped(responder);
11902
11903 handler.deprecated_get_token(responder).await;
11904 Ok(())
11905 }
11906
11907 8360374984291987687 => {
11908 let responder = ::fidl_next::Responder::from_untyped(responder);
11909
11910 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11911 Ok(decoded) => {
11912 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
11913 Ok(())
11914 }
11915 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11916 ordinal: 8360374984291987687,
11917 error,
11918 }),
11919 }
11920 }
11921
11922 8433556716759383021 => {
11923 let responder = ::fidl_next::Responder::from_untyped(responder);
11924
11925 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11926 Ok(decoded) => {
11927 handler
11928 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
11929 .await;
11930 Ok(())
11931 }
11932 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11933 ordinal: 8433556716759383021,
11934 error,
11935 }),
11936 }
11937 }
11938
11939 8097726607824333022 => {
11940 let responder = ::fidl_next::Responder::from_untyped(responder);
11941
11942 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11943 Ok(decoded) => {
11944 handler
11945 .rename(::fidl_next::Request::from_decoded(decoded), responder)
11946 .await;
11947 Ok(())
11948 }
11949 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11950 ordinal: 8097726607824333022,
11951 error,
11952 }),
11953 }
11954 }
11955
11956 2435901052462315657 => {
11957 let responder = ::fidl_next::Responder::from_untyped(responder);
11958
11959 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11960 Ok(decoded) => {
11961 handler
11962 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
11963 .await;
11964 Ok(())
11965 }
11966 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11967 ordinal: 2435901052462315657,
11968 error,
11969 }),
11970 }
11971 }
11972
11973 6275512344170098065 => {
11974 let responder = ::fidl_next::Responder::from_untyped(responder);
11975
11976 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11977 Ok(decoded) => {
11978 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
11979 Ok(())
11980 }
11981 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11982 ordinal: 6275512344170098065,
11983 error,
11984 }),
11985 }
11986 }
11987
11988 ordinal => {
11989 handler.on_unknown_interaction(ordinal).await;
11990 if ::core::matches!(
11991 message.header().flexibility(),
11992 ::fidl_next::protocol::Flexibility::Strict
11993 ) {
11994 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11995 } else {
11996 responder
11997 .respond_framework_error(
11998 ordinal,
11999 ::fidl_next::FrameworkError::UnknownMethod,
12000 )
12001 .expect("encoding a framework error should never fail")
12002 .await?;
12003 Ok(())
12004 }
12005 }
12006 }
12007 }
12008}
12009
12010pub trait DirectoryClientHandler<
12014 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12015 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12016>
12017{
12018 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
12019 fn on_open(
12020 &mut self,
12021
12022 request: ::fidl_next::Request<directory::OnOpen, ___T>,
12023 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12024
12025 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
12026 fn on_representation(
12027 &mut self,
12028
12029 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12030 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12031
12032 fn on_unknown_interaction(
12033 &mut self,
12034 ordinal: u64,
12035 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12036 ::core::future::ready(())
12037 }
12038}
12039
12040impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Directory
12041where
12042 ___H: DirectoryClientHandler<___T> + ::core::marker::Send,
12043 ___T: ::fidl_next::Transport,
12044 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
12045 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12046 Constraint = (),
12047 >,
12048 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
12049 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12050 Constraint = (),
12051 >,
12052{
12053 async fn on_event(
12054 handler: &mut ___H,
12055 mut message: ::fidl_next::Message<___T>,
12056 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12057 match *message.header().ordinal {
12058 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12059 Ok(decoded) => {
12060 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
12061 Ok(())
12062 }
12063 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12064 ordinal: 9207534335756671346,
12065 error,
12066 }),
12067 },
12068
12069 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12070 Ok(decoded) => {
12071 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
12072 Ok(())
12073 }
12074 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12075 ordinal: 6679970090861613324,
12076 error,
12077 }),
12078 },
12079
12080 ordinal => {
12081 handler.on_unknown_interaction(ordinal).await;
12082 if ::core::matches!(
12083 message.header().flexibility(),
12084 ::fidl_next::protocol::Flexibility::Strict
12085 ) {
12086 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12087 } else {
12088 Ok(())
12089 }
12090 }
12091 }
12092 }
12093}
12094
12095pub trait DirectoryServerHandler<
12099 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12100 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12101>
12102{
12103 #[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"]
12104 fn advisory_lock(
12105 &mut self,
12106
12107 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12108
12109 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12110 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12111
12112 fn clone(
12113 &mut self,
12114
12115 request: ::fidl_next::Request<directory::Clone, ___T>,
12116 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12117
12118 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
12119 fn close(
12120 &mut self,
12121
12122 responder: ::fidl_next::Responder<directory::Close, ___T>,
12123 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12124
12125 fn query(
12126 &mut self,
12127
12128 responder: ::fidl_next::Responder<directory::Query, ___T>,
12129 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12130
12131 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12132 fn deprecated_get_attr(
12133 &mut self,
12134
12135 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12136 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12137
12138 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
12139 fn deprecated_set_attr(
12140 &mut self,
12141
12142 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12143
12144 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12145 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12146
12147 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
12148 fn deprecated_get_flags(
12149 &mut self,
12150
12151 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12152 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12153
12154 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
12155 fn deprecated_set_flags(
12156 &mut self,
12157
12158 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12159
12160 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12161 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12162
12163 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
12164 fn get_flags(
12165 &mut self,
12166
12167 responder: ::fidl_next::Responder<directory::GetFlags, ___T>,
12168 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12169
12170 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
12171 fn set_flags(
12172 &mut self,
12173
12174 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12175
12176 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12177 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12178
12179 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
12180 fn query_filesystem(
12181 &mut self,
12182
12183 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
12184 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12185
12186 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
12187 fn get_token(
12188 &mut self,
12189
12190 responder: ::fidl_next::Responder<directory::GetToken, ___T>,
12191 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12192
12193 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
12194 fn get_attributes(
12195 &mut self,
12196
12197 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
12198
12199 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
12200 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12201
12202 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
12203 fn update_attributes(
12204 &mut self,
12205
12206 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
12207
12208 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
12209 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12210
12211 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
12212 fn sync(
12213 &mut self,
12214
12215 responder: ::fidl_next::Responder<directory::Sync, ___T>,
12216 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12217
12218 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
12219 fn list_extended_attributes(
12220 &mut self,
12221
12222 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
12223 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12224
12225 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
12226 fn get_extended_attribute(
12227 &mut self,
12228
12229 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
12230
12231 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
12232 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12233
12234 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12235 fn set_extended_attribute(
12236 &mut self,
12237
12238 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
12239
12240 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
12241 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12242
12243 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
12244 fn remove_extended_attribute(
12245 &mut self,
12246
12247 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
12248
12249 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
12250 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12251
12252 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
12253 fn open(
12254 &mut self,
12255
12256 request: ::fidl_next::Request<directory::Open, ___T>,
12257 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12258
12259 #[doc = " DEPRECATED - Use `fuchsia.io/Directory.Open` instead.\n"]
12260 fn deprecated_open(
12261 &mut self,
12262
12263 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
12264 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12265
12266 #[doc = " Reads a collection of variably sized dirents into a buffer.\n The number of dirents in a directory may be very large: akin to\n calling read multiple times on a file, directories have a seek\n offset which is updated on subsequent calls to ReadDirents.\n Each call to ReadDirents will only return whole dirent structures,\n they will not get split across ReadDirent calls. When the seek\n offset reaches the end, `dirents` will be empty.\n\n These dirents are of the form:\n ```\n struct dirent {\n // Describes the inode of the entry.\n uint64 ino;\n // Describes the length of the dirent name in bytes.\n uint8 size;\n // Describes the type of the entry. Aligned with the\n // POSIX d_type values. Use `DirentType` constants.\n uint8 type;\n // Unterminated name of entry.\n char name[0];\n }\n ```\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12267 fn read_dirents(
12268 &mut self,
12269
12270 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
12271
12272 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
12273 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12274
12275 #[doc = " Resets the directory seek offset.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12276 fn rewind(
12277 &mut self,
12278
12279 responder: ::fidl_next::Responder<directory::Rewind, ___T>,
12280 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12281
12282 #[doc = " Acquires a token to a Directory which can be used to identify access to it at a later point\n in time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE`, otherwise returns\n `ZX_ERR_BAD_HANDLE`.\n\n This method is deprecated: use `fuchsia.io/Node.GetToken` instead (once it is added).\n"]
12283 fn deprecated_get_token(
12284 &mut self,
12285
12286 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
12287 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12288
12289 #[doc = " Creates a link to an object named src by the name dst, within a directory represented by\n token.\n\n `src` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will\n return `ZX_ERR_INVALID_ARGS`.\n\n This method requires following rights: `OpenFlags.RIGHT_WRITABLE` and\n `OpenFlags.RIGHT_READABLE`, otherwise returns `ZX_ERR_BAD_HANDLE`.\n\n This will be atomic with respect to renaming or unlinking the source concurrently e.g. if\n there are two actors operating concurrently, and one actor performs a rename that affects\n the source within this directory, and the other does a link, each will appear to occur\n atomically in an unspecified order.\n"]
12290 fn link(
12291 &mut self,
12292
12293 request: ::fidl_next::Request<directory::Link, ___T>,
12294
12295 responder: ::fidl_next::Responder<directory::Link, ___T>,
12296 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12297
12298 #[doc = " Removes a child node from the this directory\'s list of entries.\n\n Note: this does not guarantee that the underlying object is destroyed.\n Although the link will be removed from the containing directory,\n objects with multiple references (such as files which are still open)\n will not actually be destroyed until all references are closed.\n\n * error `ZX_ERR_ACCESS_DENIED` if the connection does not have\n [`Rights.WRITE_BYTES`].\n * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not\n support writing.\n * error `ZX_ERR_BAD_PATH` if `name` is invalid.\n * error `ZX_ERR_NOT_EMPTY` if `name` refers to a non-empty directory.\n * error `ZX_ERR_UNAVAILABLE` if `name` refers to a mount point,\n containing a remote channel.\n * error `ZX_ERR_NOT_DIR` if the options requested a directory but\n something other than a directory was found.\n\n Other errors may be returned for filesystem-specific reasons.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n"]
12299 fn unlink(
12300 &mut self,
12301
12302 request: ::fidl_next::Request<directory::Unlink, ___T>,
12303
12304 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
12305 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12306
12307 #[doc = " Renames a node named `src` to the name `dst`, in a directory represented\n by `dst_parent_token`.\n\n `src` and `dst` must be valid node names.\n See [`Name`] for what constitutes a valid name.\n\n This method requires the following rights on both the current connection, and the connection\n identified by `dst_parent_token`:\n\n * [`Rights.ENUMERATE`]\n * [`Rights.MODIFY_DIRECTORY`]\n\n The following requirements are necessary to avoid rights escalations.\n\n If the source and destination directory differ, the source directory must also have the\n maximal set of abilities supported for files, which would typically be\n [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`], [`Rights.GET_ATTRIBUTES`] and\n [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also support the [`Rights.EXECUTE`]\n right.\n\n If `src` refers to a directory, and differs from the destination directory, then the source\n directory must have also have the [`Rights.CONNECT`] and [`Rights.TRAVERSE`] rights.\n\n * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.\n * error `ZX_ERR_ACCESS_DENIED` for insufficient rights.\n"]
12308 fn rename(
12309 &mut self,
12310
12311 request: ::fidl_next::Request<directory::Rename, ___T>,
12312
12313 responder: ::fidl_next::Responder<directory::Rename, ___T>,
12314 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12315
12316 #[doc = " Creates a symbolic link.\n\n `name` is the name to be given to the created symbolic link.\n `target` is the target of the symbolic link, which has no meaning on the server. The server\n will perform no validation of `target` except for a server chosen maximum length.\n `connection` is an optional server end of a channel that will speak the Symlink protocol\n on the successfully created node.\n\n * [`Rights.MODIFY_DIRECTORY`]\n\n * error `ZX_ERR_ALREADY_EXISTS` if `name` already exists.\n * error `ZX_ERR_BAD_PATH` if `target` exceeds the server length limit for symbolic links.\n * error `ZX_ERR_INVALID_ARGS` if `name` is not a valid [`Name`].\n * error `ZX_ERR_NOT_SUPPORTED` if creating symbolic links is not supported by the server.\n"]
12317 fn create_symlink(
12318 &mut self,
12319
12320 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
12321
12322 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
12323 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12324
12325 #[doc = " Watches a directory, receiving events of added messages on the\n watcher request channel.\n\n Options must be zero; it is reserved.\n\n This method requires the following rights:\n\n * [`Rights.ENUMERATE`]\n"]
12326 fn watch(
12327 &mut self,
12328
12329 request: ::fidl_next::Request<directory::Watch, ___T>,
12330
12331 responder: ::fidl_next::Responder<directory::Watch, ___T>,
12332 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12333
12334 fn on_unknown_interaction(
12335 &mut self,
12336 ordinal: u64,
12337 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
12338 ::core::future::ready(())
12339 }
12340}
12341
12342impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Directory
12343where
12344 ___H: DirectoryServerHandler<___T> + ::core::marker::Send,
12345 ___T: ::fidl_next::Transport,
12346 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
12347 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12348 Constraint = (),
12349 >,
12350 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
12351 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12352 Constraint = (),
12353 >,
12354 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
12355 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12356 Constraint = (),
12357 >,
12358 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
12359 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12360 Constraint = (),
12361 >,
12362 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
12363 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12364 Constraint = (),
12365 >,
12366 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
12367 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12368 Constraint = (),
12369 >,
12370 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
12371 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12372 Constraint = (),
12373 >,
12374 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
12375 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12376 Constraint = (),
12377 >,
12378 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12379 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12380 Constraint = (),
12381 >,
12382 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12383 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12384 Constraint = (),
12385 >,
12386 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
12387 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12388 Constraint = (),
12389 >,
12390 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
12391 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12392 Constraint = (),
12393 >,
12394 for<'de> crate::wire::DirectoryDeprecatedOpenRequest<'de>: ::fidl_next::Decode<
12395 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12396 Constraint = (),
12397 >,
12398 for<'de> crate::wire::DirectoryReadDirentsRequest: ::fidl_next::Decode<
12399 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12400 Constraint = (),
12401 >,
12402 for<'de> crate::wire::DirectoryLinkRequest<'de>: ::fidl_next::Decode<
12403 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12404 Constraint = (),
12405 >,
12406 for<'de> crate::wire::DirectoryUnlinkRequest<'de>: ::fidl_next::Decode<
12407 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12408 Constraint = (),
12409 >,
12410 for<'de> crate::wire::DirectoryRenameRequest<'de>: ::fidl_next::Decode<
12411 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12412 Constraint = (),
12413 >,
12414 for<'de> crate::wire::DirectoryCreateSymlinkRequest<'de>: ::fidl_next::Decode<
12415 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12416 Constraint = (),
12417 >,
12418 for<'de> crate::wire::DirectoryWatchRequest: ::fidl_next::Decode<
12419 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12420 Constraint = (),
12421 >,
12422{
12423 async fn on_one_way(
12424 handler: &mut ___H,
12425 mut message: ::fidl_next::Message<___T>,
12426 ) -> ::core::result::Result<
12427 (),
12428 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12429 > {
12430 match *message.header().ordinal {
12431 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12432 Ok(decoded) => {
12433 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
12434 Ok(())
12435 }
12436 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12437 ordinal: 2366825959783828089,
12438 error,
12439 }),
12440 },
12441
12442 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12443 Ok(decoded) => {
12444 handler
12445 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
12446 .await;
12447 Ok(())
12448 }
12449 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12450 ordinal: 5431626189872037072,
12451 error,
12452 }),
12453 },
12454
12455 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12456 Ok(decoded) => {
12457 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
12458 Ok(())
12459 }
12460 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12461 ordinal: 6236883748953765593,
12462 error,
12463 }),
12464 },
12465
12466 3193127272456937152 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
12467 Ok(decoded) => {
12468 handler.deprecated_open(::fidl_next::Request::from_decoded(decoded)).await;
12469 Ok(())
12470 }
12471 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12472 ordinal: 3193127272456937152,
12473 error,
12474 }),
12475 },
12476
12477 ordinal => {
12478 handler.on_unknown_interaction(ordinal).await;
12479 if ::core::matches!(
12480 message.header().flexibility(),
12481 ::fidl_next::protocol::Flexibility::Strict
12482 ) {
12483 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12484 } else {
12485 Ok(())
12486 }
12487 }
12488 }
12489 }
12490
12491 async fn on_two_way(
12492 handler: &mut ___H,
12493 mut message: ::fidl_next::Message<___T>,
12494 responder: ::fidl_next::protocol::Responder<___T>,
12495 ) -> ::core::result::Result<
12496 (),
12497 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12498 > {
12499 match *message.header().ordinal {
12500 7992130864415541162 => {
12501 let responder = ::fidl_next::Responder::from_untyped(responder);
12502
12503 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12504 Ok(decoded) => {
12505 handler
12506 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
12507 .await;
12508 Ok(())
12509 }
12510 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12511 ordinal: 7992130864415541162,
12512 error,
12513 }),
12514 }
12515 }
12516
12517 6540867515453498750 => {
12518 let responder = ::fidl_next::Responder::from_untyped(responder);
12519
12520 handler.close(responder).await;
12521 Ok(())
12522 }
12523
12524 2763219980499352582 => {
12525 let responder = ::fidl_next::Responder::from_untyped(responder);
12526
12527 handler.query(responder).await;
12528 Ok(())
12529 }
12530
12531 8689798978500614909 => {
12532 let responder = ::fidl_next::Responder::from_untyped(responder);
12533
12534 handler.deprecated_get_attr(responder).await;
12535 Ok(())
12536 }
12537
12538 4721673413776871238 => {
12539 let responder = ::fidl_next::Responder::from_untyped(responder);
12540
12541 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12542 Ok(decoded) => {
12543 handler
12544 .deprecated_set_attr(
12545 ::fidl_next::Request::from_decoded(decoded),
12546 responder,
12547 )
12548 .await;
12549 Ok(())
12550 }
12551 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12552 ordinal: 4721673413776871238,
12553 error,
12554 }),
12555 }
12556 }
12557
12558 6595803110182632097 => {
12559 let responder = ::fidl_next::Responder::from_untyped(responder);
12560
12561 handler.deprecated_get_flags(responder).await;
12562 Ok(())
12563 }
12564
12565 5950864159036794675 => {
12566 let responder = ::fidl_next::Responder::from_untyped(responder);
12567
12568 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12569 Ok(decoded) => {
12570 handler
12571 .deprecated_set_flags(
12572 ::fidl_next::Request::from_decoded(decoded),
12573 responder,
12574 )
12575 .await;
12576 Ok(())
12577 }
12578 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12579 ordinal: 5950864159036794675,
12580 error,
12581 }),
12582 }
12583 }
12584
12585 105530239381466147 => {
12586 let responder = ::fidl_next::Responder::from_untyped(responder);
12587
12588 handler.get_flags(responder).await;
12589 Ok(())
12590 }
12591
12592 6172186066099445416 => {
12593 let responder = ::fidl_next::Responder::from_untyped(responder);
12594
12595 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12596 Ok(decoded) => {
12597 handler
12598 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
12599 .await;
12600 Ok(())
12601 }
12602 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12603 ordinal: 6172186066099445416,
12604 error,
12605 }),
12606 }
12607 }
12608
12609 8013111122914313744 => {
12610 let responder = ::fidl_next::Responder::from_untyped(responder);
12611
12612 handler.query_filesystem(responder).await;
12613 Ok(())
12614 }
12615
12616 5788516050773961964 => {
12617 let responder = ::fidl_next::Responder::from_untyped(responder);
12618
12619 handler.get_token(responder).await;
12620 Ok(())
12621 }
12622
12623 4414537700416816443 => {
12624 let responder = ::fidl_next::Responder::from_untyped(responder);
12625
12626 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12627 Ok(decoded) => {
12628 handler
12629 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
12630 .await;
12631 Ok(())
12632 }
12633 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12634 ordinal: 4414537700416816443,
12635 error,
12636 }),
12637 }
12638 }
12639
12640 3677402239314018056 => {
12641 let responder = ::fidl_next::Responder::from_untyped(responder);
12642
12643 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12644 Ok(decoded) => {
12645 handler
12646 .update_attributes(
12647 ::fidl_next::Request::from_decoded(decoded),
12648 responder,
12649 )
12650 .await;
12651 Ok(())
12652 }
12653 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12654 ordinal: 3677402239314018056,
12655 error,
12656 }),
12657 }
12658 }
12659
12660 3196473584242777161 => {
12661 let responder = ::fidl_next::Responder::from_untyped(responder);
12662
12663 handler.sync(responder).await;
12664 Ok(())
12665 }
12666
12667 5043930208506967771 => {
12668 let responder = ::fidl_next::Responder::from_untyped(responder);
12669
12670 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12671 Ok(decoded) => {
12672 handler
12673 .get_extended_attribute(
12674 ::fidl_next::Request::from_decoded(decoded),
12675 responder,
12676 )
12677 .await;
12678 Ok(())
12679 }
12680 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12681 ordinal: 5043930208506967771,
12682 error,
12683 }),
12684 }
12685 }
12686
12687 5374223046099989052 => {
12688 let responder = ::fidl_next::Responder::from_untyped(responder);
12689
12690 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12691 Ok(decoded) => {
12692 handler
12693 .set_extended_attribute(
12694 ::fidl_next::Request::from_decoded(decoded),
12695 responder,
12696 )
12697 .await;
12698 Ok(())
12699 }
12700 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12701 ordinal: 5374223046099989052,
12702 error,
12703 }),
12704 }
12705 }
12706
12707 8794297771444732717 => {
12708 let responder = ::fidl_next::Responder::from_untyped(responder);
12709
12710 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12711 Ok(decoded) => {
12712 handler
12713 .remove_extended_attribute(
12714 ::fidl_next::Request::from_decoded(decoded),
12715 responder,
12716 )
12717 .await;
12718 Ok(())
12719 }
12720 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12721 ordinal: 8794297771444732717,
12722 error,
12723 }),
12724 }
12725 }
12726
12727 3855785432100874762 => {
12728 let responder = ::fidl_next::Responder::from_untyped(responder);
12729
12730 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12731 Ok(decoded) => {
12732 handler
12733 .read_dirents(::fidl_next::Request::from_decoded(decoded), responder)
12734 .await;
12735 Ok(())
12736 }
12737 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12738 ordinal: 3855785432100874762,
12739 error,
12740 }),
12741 }
12742 }
12743
12744 1635123508515392625 => {
12745 let responder = ::fidl_next::Responder::from_untyped(responder);
12746
12747 handler.rewind(responder).await;
12748 Ok(())
12749 }
12750
12751 2787337947777369685 => {
12752 let responder = ::fidl_next::Responder::from_untyped(responder);
12753
12754 handler.deprecated_get_token(responder).await;
12755 Ok(())
12756 }
12757
12758 8360374984291987687 => {
12759 let responder = ::fidl_next::Responder::from_untyped(responder);
12760
12761 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12762 Ok(decoded) => {
12763 handler.link(::fidl_next::Request::from_decoded(decoded), responder).await;
12764 Ok(())
12765 }
12766 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12767 ordinal: 8360374984291987687,
12768 error,
12769 }),
12770 }
12771 }
12772
12773 8433556716759383021 => {
12774 let responder = ::fidl_next::Responder::from_untyped(responder);
12775
12776 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12777 Ok(decoded) => {
12778 handler
12779 .unlink(::fidl_next::Request::from_decoded(decoded), responder)
12780 .await;
12781 Ok(())
12782 }
12783 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12784 ordinal: 8433556716759383021,
12785 error,
12786 }),
12787 }
12788 }
12789
12790 8097726607824333022 => {
12791 let responder = ::fidl_next::Responder::from_untyped(responder);
12792
12793 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12794 Ok(decoded) => {
12795 handler
12796 .rename(::fidl_next::Request::from_decoded(decoded), responder)
12797 .await;
12798 Ok(())
12799 }
12800 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12801 ordinal: 8097726607824333022,
12802 error,
12803 }),
12804 }
12805 }
12806
12807 2435901052462315657 => {
12808 let responder = ::fidl_next::Responder::from_untyped(responder);
12809
12810 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12811 Ok(decoded) => {
12812 handler
12813 .create_symlink(::fidl_next::Request::from_decoded(decoded), responder)
12814 .await;
12815 Ok(())
12816 }
12817 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12818 ordinal: 2435901052462315657,
12819 error,
12820 }),
12821 }
12822 }
12823
12824 6275512344170098065 => {
12825 let responder = ::fidl_next::Responder::from_untyped(responder);
12826
12827 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12828 Ok(decoded) => {
12829 handler.watch(::fidl_next::Request::from_decoded(decoded), responder).await;
12830 Ok(())
12831 }
12832 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12833 ordinal: 6275512344170098065,
12834 error,
12835 }),
12836 }
12837 }
12838
12839 ordinal => {
12840 handler.on_unknown_interaction(ordinal).await;
12841 if ::core::matches!(
12842 message.header().flexibility(),
12843 ::fidl_next::protocol::Flexibility::Strict
12844 ) {
12845 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
12846 } else {
12847 responder
12848 .respond_framework_error(
12849 ordinal,
12850 ::fidl_next::FrameworkError::UnknownMethod,
12851 )
12852 .expect("encoding a framework error should never fail")
12853 .await?;
12854 Ok(())
12855 }
12856 }
12857 }
12858 }
12859}
12860
12861impl<___T> DirectoryClientHandler<___T> for ::fidl_next::IgnoreEvents
12862where
12863 ___T: ::fidl_next::Transport,
12864{
12865 async fn on_open(&mut self, _: ::fidl_next::Request<directory::OnOpen, ___T>) {}
12866
12867 async fn on_representation(
12868 &mut self,
12869
12870 _: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12871 ) {
12872 }
12873
12874 async fn on_unknown_interaction(&mut self, _: u64) {}
12875}
12876
12877impl<___H, ___T> DirectoryLocalClientHandler<___T> for ::fidl_next::Local<___H>
12878where
12879 ___H: DirectoryClientHandler<___T>,
12880 ___T: ::fidl_next::Transport,
12881{
12882 async fn on_open(&mut self, request: ::fidl_next::Request<directory::OnOpen, ___T>) {
12883 ___H::on_open(&mut self.0, request).await
12884 }
12885
12886 async fn on_representation(
12887 &mut self,
12888
12889 request: ::fidl_next::Request<directory::OnRepresentation, ___T>,
12890 ) {
12891 ___H::on_representation(&mut self.0, request).await
12892 }
12893
12894 async fn on_unknown_interaction(&mut self, ordinal: u64) {
12895 ___H::on_unknown_interaction(&mut self.0, ordinal).await
12896 }
12897}
12898
12899impl<___H, ___T> DirectoryLocalServerHandler<___T> for ::fidl_next::Local<___H>
12900where
12901 ___H: DirectoryServerHandler<___T>,
12902 ___T: ::fidl_next::Transport,
12903{
12904 async fn advisory_lock(
12905 &mut self,
12906
12907 request: ::fidl_next::Request<directory::AdvisoryLock, ___T>,
12908
12909 responder: ::fidl_next::Responder<directory::AdvisoryLock, ___T>,
12910 ) {
12911 ___H::advisory_lock(&mut self.0, request, responder).await
12912 }
12913
12914 async fn clone(&mut self, request: ::fidl_next::Request<directory::Clone, ___T>) {
12915 ___H::clone(&mut self.0, request).await
12916 }
12917
12918 async fn close(&mut self, responder: ::fidl_next::Responder<directory::Close, ___T>) {
12919 ___H::close(&mut self.0, responder).await
12920 }
12921
12922 async fn query(&mut self, responder: ::fidl_next::Responder<directory::Query, ___T>) {
12923 ___H::query(&mut self.0, responder).await
12924 }
12925
12926 async fn deprecated_get_attr(
12927 &mut self,
12928
12929 responder: ::fidl_next::Responder<directory::DeprecatedGetAttr, ___T>,
12930 ) {
12931 ___H::deprecated_get_attr(&mut self.0, responder).await
12932 }
12933
12934 async fn deprecated_set_attr(
12935 &mut self,
12936
12937 request: ::fidl_next::Request<directory::DeprecatedSetAttr, ___T>,
12938
12939 responder: ::fidl_next::Responder<directory::DeprecatedSetAttr, ___T>,
12940 ) {
12941 ___H::deprecated_set_attr(&mut self.0, request, responder).await
12942 }
12943
12944 async fn deprecated_get_flags(
12945 &mut self,
12946
12947 responder: ::fidl_next::Responder<directory::DeprecatedGetFlags, ___T>,
12948 ) {
12949 ___H::deprecated_get_flags(&mut self.0, responder).await
12950 }
12951
12952 async fn deprecated_set_flags(
12953 &mut self,
12954
12955 request: ::fidl_next::Request<directory::DeprecatedSetFlags, ___T>,
12956
12957 responder: ::fidl_next::Responder<directory::DeprecatedSetFlags, ___T>,
12958 ) {
12959 ___H::deprecated_set_flags(&mut self.0, request, responder).await
12960 }
12961
12962 async fn get_flags(&mut self, responder: ::fidl_next::Responder<directory::GetFlags, ___T>) {
12963 ___H::get_flags(&mut self.0, responder).await
12964 }
12965
12966 async fn set_flags(
12967 &mut self,
12968
12969 request: ::fidl_next::Request<directory::SetFlags, ___T>,
12970
12971 responder: ::fidl_next::Responder<directory::SetFlags, ___T>,
12972 ) {
12973 ___H::set_flags(&mut self.0, request, responder).await
12974 }
12975
12976 async fn query_filesystem(
12977 &mut self,
12978
12979 responder: ::fidl_next::Responder<directory::QueryFilesystem, ___T>,
12980 ) {
12981 ___H::query_filesystem(&mut self.0, responder).await
12982 }
12983
12984 async fn get_token(&mut self, responder: ::fidl_next::Responder<directory::GetToken, ___T>) {
12985 ___H::get_token(&mut self.0, responder).await
12986 }
12987
12988 async fn get_attributes(
12989 &mut self,
12990
12991 request: ::fidl_next::Request<directory::GetAttributes, ___T>,
12992
12993 responder: ::fidl_next::Responder<directory::GetAttributes, ___T>,
12994 ) {
12995 ___H::get_attributes(&mut self.0, request, responder).await
12996 }
12997
12998 async fn update_attributes(
12999 &mut self,
13000
13001 request: ::fidl_next::Request<directory::UpdateAttributes, ___T>,
13002
13003 responder: ::fidl_next::Responder<directory::UpdateAttributes, ___T>,
13004 ) {
13005 ___H::update_attributes(&mut self.0, request, responder).await
13006 }
13007
13008 async fn sync(&mut self, responder: ::fidl_next::Responder<directory::Sync, ___T>) {
13009 ___H::sync(&mut self.0, responder).await
13010 }
13011
13012 async fn list_extended_attributes(
13013 &mut self,
13014
13015 request: ::fidl_next::Request<directory::ListExtendedAttributes, ___T>,
13016 ) {
13017 ___H::list_extended_attributes(&mut self.0, request).await
13018 }
13019
13020 async fn get_extended_attribute(
13021 &mut self,
13022
13023 request: ::fidl_next::Request<directory::GetExtendedAttribute, ___T>,
13024
13025 responder: ::fidl_next::Responder<directory::GetExtendedAttribute, ___T>,
13026 ) {
13027 ___H::get_extended_attribute(&mut self.0, request, responder).await
13028 }
13029
13030 async fn set_extended_attribute(
13031 &mut self,
13032
13033 request: ::fidl_next::Request<directory::SetExtendedAttribute, ___T>,
13034
13035 responder: ::fidl_next::Responder<directory::SetExtendedAttribute, ___T>,
13036 ) {
13037 ___H::set_extended_attribute(&mut self.0, request, responder).await
13038 }
13039
13040 async fn remove_extended_attribute(
13041 &mut self,
13042
13043 request: ::fidl_next::Request<directory::RemoveExtendedAttribute, ___T>,
13044
13045 responder: ::fidl_next::Responder<directory::RemoveExtendedAttribute, ___T>,
13046 ) {
13047 ___H::remove_extended_attribute(&mut self.0, request, responder).await
13048 }
13049
13050 async fn open(&mut self, request: ::fidl_next::Request<directory::Open, ___T>) {
13051 ___H::open(&mut self.0, request).await
13052 }
13053
13054 async fn deprecated_open(
13055 &mut self,
13056
13057 request: ::fidl_next::Request<directory::DeprecatedOpen, ___T>,
13058 ) {
13059 ___H::deprecated_open(&mut self.0, request).await
13060 }
13061
13062 async fn read_dirents(
13063 &mut self,
13064
13065 request: ::fidl_next::Request<directory::ReadDirents, ___T>,
13066
13067 responder: ::fidl_next::Responder<directory::ReadDirents, ___T>,
13068 ) {
13069 ___H::read_dirents(&mut self.0, request, responder).await
13070 }
13071
13072 async fn rewind(&mut self, responder: ::fidl_next::Responder<directory::Rewind, ___T>) {
13073 ___H::rewind(&mut self.0, responder).await
13074 }
13075
13076 async fn deprecated_get_token(
13077 &mut self,
13078
13079 responder: ::fidl_next::Responder<directory::DeprecatedGetToken, ___T>,
13080 ) {
13081 ___H::deprecated_get_token(&mut self.0, responder).await
13082 }
13083
13084 async fn link(
13085 &mut self,
13086
13087 request: ::fidl_next::Request<directory::Link, ___T>,
13088
13089 responder: ::fidl_next::Responder<directory::Link, ___T>,
13090 ) {
13091 ___H::link(&mut self.0, request, responder).await
13092 }
13093
13094 async fn unlink(
13095 &mut self,
13096
13097 request: ::fidl_next::Request<directory::Unlink, ___T>,
13098
13099 responder: ::fidl_next::Responder<directory::Unlink, ___T>,
13100 ) {
13101 ___H::unlink(&mut self.0, request, responder).await
13102 }
13103
13104 async fn rename(
13105 &mut self,
13106
13107 request: ::fidl_next::Request<directory::Rename, ___T>,
13108
13109 responder: ::fidl_next::Responder<directory::Rename, ___T>,
13110 ) {
13111 ___H::rename(&mut self.0, request, responder).await
13112 }
13113
13114 async fn create_symlink(
13115 &mut self,
13116
13117 request: ::fidl_next::Request<directory::CreateSymlink, ___T>,
13118
13119 responder: ::fidl_next::Responder<directory::CreateSymlink, ___T>,
13120 ) {
13121 ___H::create_symlink(&mut self.0, request, responder).await
13122 }
13123
13124 async fn watch(
13125 &mut self,
13126
13127 request: ::fidl_next::Request<directory::Watch, ___T>,
13128
13129 responder: ::fidl_next::Responder<directory::Watch, ___T>,
13130 ) {
13131 ___H::watch(&mut self.0, request, responder).await
13132 }
13133
13134 async fn on_unknown_interaction(&mut self, ordinal: u64) {
13135 ___H::on_unknown_interaction(&mut self.0, ordinal).await
13136 }
13137}
13138
13139#[derive(PartialEq, Debug)]
13141pub struct Linkable;
13142
13143#[cfg(target_os = "fuchsia")]
13144impl ::fidl_next::HasTransport for Linkable {
13145 type Transport = ::fidl_next::fuchsia::zx::Channel;
13146}
13147
13148pub mod linkable {
13149 pub mod prelude {
13150 pub use crate::{
13151 Linkable, LinkableClientHandler, LinkableLocalClientHandler,
13152 LinkableLocalServerHandler, LinkableServerHandler, linkable,
13153 };
13154
13155 pub use crate::natural::LinkableLinkIntoRequest;
13156
13157 pub use crate::natural::LinkableLinkIntoResponse;
13158 }
13159
13160 pub struct LinkInto;
13161
13162 impl ::fidl_next::Method for LinkInto {
13163 const ORDINAL: u64 = 6121399674497678964;
13164 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13165 ::fidl_next::protocol::Flexibility::Strict;
13166
13167 type Protocol = crate::Linkable;
13168
13169 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13170 }
13171
13172 impl ::fidl_next::TwoWayMethod for LinkInto {
13173 type Response = ::fidl_next::wire::Result<
13174 'static,
13175 crate::wire::LinkableLinkIntoResponse,
13176 ::fidl_next::wire::fuchsia::Status,
13177 >;
13178 }
13179
13180 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13181 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13182
13183 fn respond(response: ___R) -> Self::Output {
13184 ::core::result::Result::Ok(response)
13185 }
13186 }
13187
13188 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13189 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13190
13191 fn respond_err(response: ___R) -> Self::Output {
13192 ::core::result::Result::Err(response)
13193 }
13194 }
13195
13196 mod ___detail {
13197 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Linkable
13198 where
13199 ___T: ::fidl_next::Transport,
13200 {
13201 type Client = LinkableClient<___T>;
13202 type Server = LinkableServer<___T>;
13203 }
13204
13205 #[repr(transparent)]
13207 pub struct LinkableClient<___T: ::fidl_next::Transport> {
13208 #[allow(dead_code)]
13209 client: ::fidl_next::protocol::Client<___T>,
13210 }
13211
13212 impl<___T> LinkableClient<___T>
13213 where
13214 ___T: ::fidl_next::Transport,
13215 {
13216 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13217 pub fn link_into(
13218 &self,
13219
13220 dst_parent_token: impl ::fidl_next::Encode<
13221 ::fidl_next::wire::fuchsia::Event,
13222 <___T as ::fidl_next::Transport>::SendBuffer,
13223 >,
13224
13225 dst: impl ::fidl_next::Encode<
13226 ::fidl_next::wire::String<'static>,
13227 <___T as ::fidl_next::Transport>::SendBuffer,
13228 >,
13229 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13230 where
13231 <___T as ::fidl_next::Transport>::SendBuffer:
13232 ::fidl_next::encoder::InternalHandleEncoder,
13233 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
13234 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
13235 {
13236 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
13237 dst_parent_token,
13238
13239 dst,
13240 })
13241 }
13242
13243 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13244 pub fn link_into_with<___R>(
13245 &self,
13246 request: ___R,
13247 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
13248 where
13249 ___R: ::fidl_next::Encode<
13250 crate::wire::LinkableLinkIntoRequest<'static>,
13251 <___T as ::fidl_next::Transport>::SendBuffer,
13252 >,
13253 {
13254 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13255 6121399674497678964,
13256 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
13257 request,
13258 ))
13259 }
13260 }
13261
13262 #[repr(transparent)]
13264 pub struct LinkableServer<___T: ::fidl_next::Transport> {
13265 server: ::fidl_next::protocol::Server<___T>,
13266 }
13267
13268 impl<___T> LinkableServer<___T> where ___T: ::fidl_next::Transport {}
13269 }
13270}
13271
13272#[diagnostic::on_unimplemented(
13273 note = "If {Self} implements the non-local LinkableClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
13274)]
13275
13276pub trait LinkableLocalClientHandler<
13280 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13281 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13282>
13283{
13284}
13285
13286impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Linkable
13287where
13288 ___H: LinkableLocalClientHandler<___T>,
13289 ___T: ::fidl_next::Transport,
13290{
13291 async fn on_event(
13292 handler: &mut ___H,
13293 mut message: ::fidl_next::Message<___T>,
13294 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13295 match *message.header().ordinal {
13296 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13297 }
13298 }
13299}
13300
13301#[diagnostic::on_unimplemented(
13302 note = "If {Self} implements the non-local LinkableServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
13303)]
13304
13305pub trait LinkableLocalServerHandler<
13309 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13310 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13311>
13312{
13313 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13314 fn link_into(
13315 &mut self,
13316
13317 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13318
13319 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13320 ) -> impl ::core::future::Future<Output = ()>;
13321}
13322
13323impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Linkable
13324where
13325 ___H: LinkableLocalServerHandler<___T>,
13326 ___T: ::fidl_next::Transport,
13327 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
13328 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13329 Constraint = (),
13330 >,
13331{
13332 async fn on_one_way(
13333 handler: &mut ___H,
13334 mut message: ::fidl_next::Message<___T>,
13335 ) -> ::core::result::Result<
13336 (),
13337 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13338 > {
13339 match *message.header().ordinal {
13340 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13341 }
13342 }
13343
13344 async fn on_two_way(
13345 handler: &mut ___H,
13346 mut message: ::fidl_next::Message<___T>,
13347 responder: ::fidl_next::protocol::Responder<___T>,
13348 ) -> ::core::result::Result<
13349 (),
13350 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13351 > {
13352 match *message.header().ordinal {
13353 6121399674497678964 => {
13354 let responder = ::fidl_next::Responder::from_untyped(responder);
13355
13356 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13357 Ok(decoded) => {
13358 handler
13359 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
13360 .await;
13361 Ok(())
13362 }
13363 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13364 ordinal: 6121399674497678964,
13365 error,
13366 }),
13367 }
13368 }
13369
13370 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13371 }
13372 }
13373}
13374
13375pub trait LinkableClientHandler<
13379 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13380 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13381>
13382{
13383}
13384
13385impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Linkable
13386where
13387 ___H: LinkableClientHandler<___T> + ::core::marker::Send,
13388 ___T: ::fidl_next::Transport,
13389{
13390 async fn on_event(
13391 handler: &mut ___H,
13392 mut message: ::fidl_next::Message<___T>,
13393 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13394 match *message.header().ordinal {
13395 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13396 }
13397 }
13398}
13399
13400pub trait LinkableServerHandler<
13404 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13405 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13406>
13407{
13408 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
13409 fn link_into(
13410 &mut self,
13411
13412 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13413
13414 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13415 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13416}
13417
13418impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Linkable
13419where
13420 ___H: LinkableServerHandler<___T> + ::core::marker::Send,
13421 ___T: ::fidl_next::Transport,
13422 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
13423 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13424 Constraint = (),
13425 >,
13426{
13427 async fn on_one_way(
13428 handler: &mut ___H,
13429 mut message: ::fidl_next::Message<___T>,
13430 ) -> ::core::result::Result<
13431 (),
13432 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13433 > {
13434 match *message.header().ordinal {
13435 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13436 }
13437 }
13438
13439 async fn on_two_way(
13440 handler: &mut ___H,
13441 mut message: ::fidl_next::Message<___T>,
13442 responder: ::fidl_next::protocol::Responder<___T>,
13443 ) -> ::core::result::Result<
13444 (),
13445 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13446 > {
13447 match *message.header().ordinal {
13448 6121399674497678964 => {
13449 let responder = ::fidl_next::Responder::from_untyped(responder);
13450
13451 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13452 Ok(decoded) => {
13453 handler
13454 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
13455 .await;
13456 Ok(())
13457 }
13458 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13459 ordinal: 6121399674497678964,
13460 error,
13461 }),
13462 }
13463 }
13464
13465 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13466 }
13467 }
13468}
13469
13470impl<___T> LinkableClientHandler<___T> for ::fidl_next::IgnoreEvents where
13471 ___T: ::fidl_next::Transport
13472{
13473}
13474
13475impl<___H, ___T> LinkableLocalClientHandler<___T> for ::fidl_next::Local<___H>
13476where
13477 ___H: LinkableClientHandler<___T>,
13478 ___T: ::fidl_next::Transport,
13479{
13480}
13481
13482impl<___H, ___T> LinkableLocalServerHandler<___T> for ::fidl_next::Local<___H>
13483where
13484 ___H: LinkableServerHandler<___T>,
13485 ___T: ::fidl_next::Transport,
13486{
13487 async fn link_into(
13488 &mut self,
13489
13490 request: ::fidl_next::Request<linkable::LinkInto, ___T>,
13491
13492 responder: ::fidl_next::Responder<linkable::LinkInto, ___T>,
13493 ) {
13494 ___H::link_into(&mut self.0, request, responder).await
13495 }
13496}
13497
13498#[doc = " A [`Node`] which contains a sequence of bytes of definite length.\n\n NOTE: cloned connections do not share their seek offset with their source\n connection.\n"]
13500#[derive(PartialEq, Debug)]
13501pub struct File;
13502
13503impl ::fidl_next::Discoverable for File {
13504 const PROTOCOL_NAME: &'static str = "fuchsia.io.File";
13505}
13506
13507#[cfg(target_os = "fuchsia")]
13508impl ::fidl_next::HasTransport for File {
13509 type Transport = ::fidl_next::fuchsia::zx::Channel;
13510}
13511
13512pub mod file {
13513 pub mod prelude {
13514 pub use crate::{
13515 File, FileClientHandler, FileLocalClientHandler, FileLocalServerHandler,
13516 FileServerHandler, file,
13517 };
13518
13519 pub use crate::natural::AdvisoryLockingAdvisoryLockRequest;
13520
13521 pub use crate::natural::AdvisoryLockingAdvisoryLockResponse;
13522
13523 pub use crate::natural::ExtendedAttributeValue;
13524
13525 pub use crate::natural::FileAllocateRequest;
13526
13527 pub use crate::natural::FileEnableVerityRequest;
13528
13529 pub use crate::natural::FileGetBackingMemoryRequest;
13530
13531 pub use crate::natural::FileInfo;
13532
13533 pub use crate::natural::FileReadAtRequest;
13534
13535 pub use crate::natural::FileResizeRequest;
13536
13537 pub use crate::natural::FileSeekRequest;
13538
13539 pub use crate::natural::FileWriteAtRequest;
13540
13541 pub use crate::natural::FileAllocateResponse;
13542
13543 pub use crate::natural::FileEnableVerityResponse;
13544
13545 pub use crate::natural::FileGetBackingMemoryResponse;
13546
13547 pub use crate::natural::FileReadAtResponse;
13548
13549 pub use crate::natural::FileResizeResponse;
13550
13551 pub use crate::natural::FileSeekResponse;
13552
13553 pub use crate::natural::FileWriteAtResponse;
13554
13555 pub use crate::natural::LinkableLinkIntoRequest;
13556
13557 pub use crate::natural::LinkableLinkIntoResponse;
13558
13559 pub use crate::natural::MutableNodeAttributes;
13560
13561 pub use crate::natural::NodeAttributes2;
13562
13563 pub use crate::natural::NodeDeprecatedGetAttrResponse;
13564
13565 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
13566
13567 pub use crate::natural::NodeDeprecatedSetAttrRequest;
13568
13569 pub use crate::natural::NodeDeprecatedSetAttrResponse;
13570
13571 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
13572
13573 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
13574
13575 pub use crate::natural::NodeGetAttributesRequest;
13576
13577 pub use crate::natural::NodeGetExtendedAttributeRequest;
13578
13579 pub use crate::natural::NodeListExtendedAttributesRequest;
13580
13581 pub use crate::natural::NodeOnOpenRequest;
13582
13583 pub use crate::natural::NodeQueryFilesystemResponse;
13584
13585 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
13586
13587 pub use crate::natural::NodeSetExtendedAttributeRequest;
13588
13589 pub use crate::natural::NodeSetFlagsRequest;
13590
13591 pub use crate::natural::NodeGetFlagsResponse;
13592
13593 pub use crate::natural::NodeGetTokenResponse;
13594
13595 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
13596
13597 pub use crate::natural::NodeSetExtendedAttributeResponse;
13598
13599 pub use crate::natural::NodeSetFlagsResponse;
13600
13601 pub use crate::natural::NodeSyncResponse;
13602
13603 pub use crate::natural::NodeUpdateAttributesResponse;
13604
13605 pub use crate::natural::ReadableReadRequest;
13606
13607 pub use crate::natural::ReadableReadResponse;
13608
13609 pub use crate::natural::Representation;
13610
13611 pub use crate::natural::WritableWriteRequest;
13612
13613 pub use crate::natural::WritableWriteResponse;
13614
13615 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
13616
13617 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
13618
13619 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
13620 }
13621
13622 pub struct AdvisoryLock;
13623
13624 impl ::fidl_next::Method for AdvisoryLock {
13625 const ORDINAL: u64 = 7992130864415541162;
13626 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13627 ::fidl_next::protocol::Flexibility::Strict;
13628
13629 type Protocol = crate::File;
13630
13631 type Request = crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>;
13632 }
13633
13634 impl ::fidl_next::TwoWayMethod for AdvisoryLock {
13635 type Response = ::fidl_next::wire::Result<
13636 'static,
13637 crate::wire::AdvisoryLockingAdvisoryLockResponse,
13638 ::fidl_next::wire::fuchsia::Status,
13639 >;
13640 }
13641
13642 impl<___R> ::fidl_next::Respond<___R> for AdvisoryLock {
13643 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13644
13645 fn respond(response: ___R) -> Self::Output {
13646 ::core::result::Result::Ok(response)
13647 }
13648 }
13649
13650 impl<___R> ::fidl_next::RespondErr<___R> for AdvisoryLock {
13651 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13652
13653 fn respond_err(response: ___R) -> Self::Output {
13654 ::core::result::Result::Err(response)
13655 }
13656 }
13657
13658 pub struct LinkInto;
13659
13660 impl ::fidl_next::Method for LinkInto {
13661 const ORDINAL: u64 = 6121399674497678964;
13662 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13663 ::fidl_next::protocol::Flexibility::Strict;
13664
13665 type Protocol = crate::File;
13666
13667 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
13668 }
13669
13670 impl ::fidl_next::TwoWayMethod for LinkInto {
13671 type Response = ::fidl_next::wire::Result<
13672 'static,
13673 crate::wire::LinkableLinkIntoResponse,
13674 ::fidl_next::wire::fuchsia::Status,
13675 >;
13676 }
13677
13678 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
13679 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13680
13681 fn respond(response: ___R) -> Self::Output {
13682 ::core::result::Result::Ok(response)
13683 }
13684 }
13685
13686 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
13687 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13688
13689 fn respond_err(response: ___R) -> Self::Output {
13690 ::core::result::Result::Err(response)
13691 }
13692 }
13693
13694 pub struct Clone;
13695
13696 impl ::fidl_next::Method for Clone {
13697 const ORDINAL: u64 = 2366825959783828089;
13698 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13699 ::fidl_next::protocol::Flexibility::Strict;
13700
13701 type Protocol = crate::File;
13702
13703 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
13704 }
13705
13706 pub struct Close;
13707
13708 impl ::fidl_next::Method for Close {
13709 const ORDINAL: u64 = 6540867515453498750;
13710 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13711 ::fidl_next::protocol::Flexibility::Strict;
13712
13713 type Protocol = crate::File;
13714
13715 type Request = ::fidl_next::wire::EmptyMessageBody;
13716 }
13717
13718 impl ::fidl_next::TwoWayMethod for Close {
13719 type Response = ::fidl_next::wire::Result<
13720 'static,
13721 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
13722 ::fidl_next::wire::Int32,
13723 >;
13724 }
13725
13726 impl<___R> ::fidl_next::Respond<___R> for Close {
13727 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13728
13729 fn respond(response: ___R) -> Self::Output {
13730 ::core::result::Result::Ok(response)
13731 }
13732 }
13733
13734 impl<___R> ::fidl_next::RespondErr<___R> for Close {
13735 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13736
13737 fn respond_err(response: ___R) -> Self::Output {
13738 ::core::result::Result::Err(response)
13739 }
13740 }
13741
13742 pub struct Query;
13743
13744 impl ::fidl_next::Method for Query {
13745 const ORDINAL: u64 = 2763219980499352582;
13746 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13747 ::fidl_next::protocol::Flexibility::Strict;
13748
13749 type Protocol = crate::File;
13750
13751 type Request = ::fidl_next::wire::EmptyMessageBody;
13752 }
13753
13754 impl ::fidl_next::TwoWayMethod for Query {
13755 type Response = ::fidl_next::wire::Strict<
13756 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
13757 >;
13758 }
13759
13760 impl<___R> ::fidl_next::Respond<___R> for Query {
13761 type Output =
13762 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
13763
13764 fn respond(response: ___R) -> Self::Output {
13765 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
13766 protocol: response,
13767 })
13768 }
13769 }
13770
13771 pub struct OnOpen;
13772
13773 impl ::fidl_next::Method for OnOpen {
13774 const ORDINAL: u64 = 9207534335756671346;
13775 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13776 ::fidl_next::protocol::Flexibility::Flexible;
13777
13778 type Protocol = crate::File;
13779
13780 type Request = crate::wire::NodeOnOpenRequest<'static>;
13781 }
13782
13783 pub struct DeprecatedGetAttr;
13784
13785 impl ::fidl_next::Method for DeprecatedGetAttr {
13786 const ORDINAL: u64 = 8689798978500614909;
13787 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13788 ::fidl_next::protocol::Flexibility::Strict;
13789
13790 type Protocol = crate::File;
13791
13792 type Request = ::fidl_next::wire::EmptyMessageBody;
13793 }
13794
13795 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
13796 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
13797 }
13798
13799 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
13800 type Output = ::fidl_next::Strict<___R>;
13801
13802 fn respond(response: ___R) -> Self::Output {
13803 ::fidl_next::Strict(response)
13804 }
13805 }
13806
13807 pub struct DeprecatedSetAttr;
13808
13809 impl ::fidl_next::Method for DeprecatedSetAttr {
13810 const ORDINAL: u64 = 4721673413776871238;
13811 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13812 ::fidl_next::protocol::Flexibility::Strict;
13813
13814 type Protocol = crate::File;
13815
13816 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
13817 }
13818
13819 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
13820 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
13821 }
13822
13823 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
13824 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
13825
13826 fn respond(response: ___R) -> Self::Output {
13827 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
13828 }
13829 }
13830
13831 pub struct DeprecatedGetFlags;
13832
13833 impl ::fidl_next::Method for DeprecatedGetFlags {
13834 const ORDINAL: u64 = 6595803110182632097;
13835 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13836 ::fidl_next::protocol::Flexibility::Strict;
13837
13838 type Protocol = crate::File;
13839
13840 type Request = ::fidl_next::wire::EmptyMessageBody;
13841 }
13842
13843 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
13844 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
13845 }
13846
13847 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
13848 type Output = ::fidl_next::Strict<___R>;
13849
13850 fn respond(response: ___R) -> Self::Output {
13851 ::fidl_next::Strict(response)
13852 }
13853 }
13854
13855 pub struct DeprecatedSetFlags;
13856
13857 impl ::fidl_next::Method for DeprecatedSetFlags {
13858 const ORDINAL: u64 = 5950864159036794675;
13859 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13860 ::fidl_next::protocol::Flexibility::Strict;
13861
13862 type Protocol = crate::File;
13863
13864 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
13865 }
13866
13867 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
13868 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
13869 }
13870
13871 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
13872 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
13873
13874 fn respond(response: ___R) -> Self::Output {
13875 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
13876 }
13877 }
13878
13879 pub struct GetFlags;
13880
13881 impl ::fidl_next::Method for GetFlags {
13882 const ORDINAL: u64 = 105530239381466147;
13883 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13884 ::fidl_next::protocol::Flexibility::Flexible;
13885
13886 type Protocol = crate::File;
13887
13888 type Request = ::fidl_next::wire::EmptyMessageBody;
13889 }
13890
13891 impl ::fidl_next::TwoWayMethod for GetFlags {
13892 type Response = ::fidl_next::wire::Result<
13893 'static,
13894 crate::wire::NodeGetFlagsResponse,
13895 ::fidl_next::wire::fuchsia::Status,
13896 >;
13897 }
13898
13899 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
13900 type Output = ::core::result::Result<
13901 crate::generic::NodeGetFlagsResponse<___R>,
13902 ::fidl_next::never::Never,
13903 >;
13904
13905 fn respond(response: ___R) -> Self::Output {
13906 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
13907 }
13908 }
13909
13910 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
13911 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13912
13913 fn respond_err(response: ___R) -> Self::Output {
13914 ::core::result::Result::Err(response)
13915 }
13916 }
13917
13918 pub struct SetFlags;
13919
13920 impl ::fidl_next::Method for SetFlags {
13921 const ORDINAL: u64 = 6172186066099445416;
13922 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13923 ::fidl_next::protocol::Flexibility::Flexible;
13924
13925 type Protocol = crate::File;
13926
13927 type Request = crate::wire::NodeSetFlagsRequest;
13928 }
13929
13930 impl ::fidl_next::TwoWayMethod for SetFlags {
13931 type Response = ::fidl_next::wire::Result<
13932 'static,
13933 crate::wire::NodeSetFlagsResponse,
13934 ::fidl_next::wire::fuchsia::Status,
13935 >;
13936 }
13937
13938 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
13939 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
13940
13941 fn respond(response: ___R) -> Self::Output {
13942 ::core::result::Result::Ok(response)
13943 }
13944 }
13945
13946 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
13947 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
13948
13949 fn respond_err(response: ___R) -> Self::Output {
13950 ::core::result::Result::Err(response)
13951 }
13952 }
13953
13954 pub struct QueryFilesystem;
13955
13956 impl ::fidl_next::Method for QueryFilesystem {
13957 const ORDINAL: u64 = 8013111122914313744;
13958 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13959 ::fidl_next::protocol::Flexibility::Strict;
13960
13961 type Protocol = crate::File;
13962
13963 type Request = ::fidl_next::wire::EmptyMessageBody;
13964 }
13965
13966 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
13967 type Response =
13968 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
13969 }
13970
13971 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
13972 type Output = ::fidl_next::Strict<___R>;
13973
13974 fn respond(response: ___R) -> Self::Output {
13975 ::fidl_next::Strict(response)
13976 }
13977 }
13978
13979 pub struct OnRepresentation;
13980
13981 impl ::fidl_next::Method for OnRepresentation {
13982 const ORDINAL: u64 = 6679970090861613324;
13983 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13984 ::fidl_next::protocol::Flexibility::Strict;
13985
13986 type Protocol = crate::File;
13987
13988 type Request = crate::wire::Representation<'static>;
13989 }
13990
13991 pub struct GetToken;
13992
13993 impl ::fidl_next::Method for GetToken {
13994 const ORDINAL: u64 = 5788516050773961964;
13995 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
13996 ::fidl_next::protocol::Flexibility::Flexible;
13997
13998 type Protocol = crate::File;
13999
14000 type Request = ::fidl_next::wire::EmptyMessageBody;
14001 }
14002
14003 impl ::fidl_next::TwoWayMethod for GetToken {
14004 type Response = ::fidl_next::wire::Result<
14005 'static,
14006 crate::wire::NodeGetTokenResponse,
14007 ::fidl_next::wire::fuchsia::Status,
14008 >;
14009 }
14010
14011 impl<___R> ::fidl_next::Respond<___R> for GetToken {
14012 type Output = ::core::result::Result<
14013 crate::generic::NodeGetTokenResponse<___R>,
14014 ::fidl_next::never::Never,
14015 >;
14016
14017 fn respond(response: ___R) -> Self::Output {
14018 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
14019 }
14020 }
14021
14022 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
14023 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14024
14025 fn respond_err(response: ___R) -> Self::Output {
14026 ::core::result::Result::Err(response)
14027 }
14028 }
14029
14030 pub struct GetAttributes;
14031
14032 impl ::fidl_next::Method for GetAttributes {
14033 const ORDINAL: u64 = 4414537700416816443;
14034 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14035 ::fidl_next::protocol::Flexibility::Strict;
14036
14037 type Protocol = crate::File;
14038
14039 type Request = crate::wire::NodeGetAttributesRequest;
14040 }
14041
14042 impl ::fidl_next::TwoWayMethod for GetAttributes {
14043 type Response = ::fidl_next::wire::Result<
14044 'static,
14045 crate::wire::NodeAttributes2<'static>,
14046 ::fidl_next::wire::fuchsia::Status,
14047 >;
14048 }
14049
14050 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
14051 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14052
14053 fn respond(response: ___R) -> Self::Output {
14054 ::core::result::Result::Ok(response)
14055 }
14056 }
14057
14058 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
14059 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14060
14061 fn respond_err(response: ___R) -> Self::Output {
14062 ::core::result::Result::Err(response)
14063 }
14064 }
14065
14066 pub struct UpdateAttributes;
14067
14068 impl ::fidl_next::Method for UpdateAttributes {
14069 const ORDINAL: u64 = 3677402239314018056;
14070 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14071 ::fidl_next::protocol::Flexibility::Strict;
14072
14073 type Protocol = crate::File;
14074
14075 type Request = crate::wire::MutableNodeAttributes<'static>;
14076 }
14077
14078 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
14079 type Response = ::fidl_next::wire::Result<
14080 'static,
14081 crate::wire::NodeUpdateAttributesResponse,
14082 ::fidl_next::wire::fuchsia::Status,
14083 >;
14084 }
14085
14086 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
14087 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14088
14089 fn respond(response: ___R) -> Self::Output {
14090 ::core::result::Result::Ok(response)
14091 }
14092 }
14093
14094 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
14095 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14096
14097 fn respond_err(response: ___R) -> Self::Output {
14098 ::core::result::Result::Err(response)
14099 }
14100 }
14101
14102 pub struct Sync;
14103
14104 impl ::fidl_next::Method for Sync {
14105 const ORDINAL: u64 = 3196473584242777161;
14106 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14107 ::fidl_next::protocol::Flexibility::Strict;
14108
14109 type Protocol = crate::File;
14110
14111 type Request = ::fidl_next::wire::EmptyMessageBody;
14112 }
14113
14114 impl ::fidl_next::TwoWayMethod for Sync {
14115 type Response = ::fidl_next::wire::Result<
14116 'static,
14117 crate::wire::NodeSyncResponse,
14118 ::fidl_next::wire::fuchsia::Status,
14119 >;
14120 }
14121
14122 impl<___R> ::fidl_next::Respond<___R> for Sync {
14123 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14124
14125 fn respond(response: ___R) -> Self::Output {
14126 ::core::result::Result::Ok(response)
14127 }
14128 }
14129
14130 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
14131 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14132
14133 fn respond_err(response: ___R) -> Self::Output {
14134 ::core::result::Result::Err(response)
14135 }
14136 }
14137
14138 pub struct ListExtendedAttributes;
14139
14140 impl ::fidl_next::Method for ListExtendedAttributes {
14141 const ORDINAL: u64 = 5431626189872037072;
14142 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14143 ::fidl_next::protocol::Flexibility::Strict;
14144
14145 type Protocol = crate::File;
14146
14147 type Request = crate::wire::NodeListExtendedAttributesRequest;
14148 }
14149
14150 pub struct GetExtendedAttribute;
14151
14152 impl ::fidl_next::Method for GetExtendedAttribute {
14153 const ORDINAL: u64 = 5043930208506967771;
14154 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14155 ::fidl_next::protocol::Flexibility::Strict;
14156
14157 type Protocol = crate::File;
14158
14159 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
14160 }
14161
14162 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
14163 type Response = ::fidl_next::wire::Result<
14164 'static,
14165 crate::wire::ExtendedAttributeValue<'static>,
14166 ::fidl_next::wire::fuchsia::Status,
14167 >;
14168 }
14169
14170 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
14171 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14172
14173 fn respond(response: ___R) -> Self::Output {
14174 ::core::result::Result::Ok(response)
14175 }
14176 }
14177
14178 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
14179 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14180
14181 fn respond_err(response: ___R) -> Self::Output {
14182 ::core::result::Result::Err(response)
14183 }
14184 }
14185
14186 pub struct SetExtendedAttribute;
14187
14188 impl ::fidl_next::Method for SetExtendedAttribute {
14189 const ORDINAL: u64 = 5374223046099989052;
14190 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14191 ::fidl_next::protocol::Flexibility::Strict;
14192
14193 type Protocol = crate::File;
14194
14195 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
14196 }
14197
14198 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
14199 type Response = ::fidl_next::wire::Result<
14200 'static,
14201 crate::wire::NodeSetExtendedAttributeResponse,
14202 ::fidl_next::wire::fuchsia::Status,
14203 >;
14204 }
14205
14206 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
14207 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14208
14209 fn respond(response: ___R) -> Self::Output {
14210 ::core::result::Result::Ok(response)
14211 }
14212 }
14213
14214 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
14215 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14216
14217 fn respond_err(response: ___R) -> Self::Output {
14218 ::core::result::Result::Err(response)
14219 }
14220 }
14221
14222 pub struct RemoveExtendedAttribute;
14223
14224 impl ::fidl_next::Method for RemoveExtendedAttribute {
14225 const ORDINAL: u64 = 8794297771444732717;
14226 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14227 ::fidl_next::protocol::Flexibility::Strict;
14228
14229 type Protocol = crate::File;
14230
14231 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
14232 }
14233
14234 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
14235 type Response = ::fidl_next::wire::Result<
14236 'static,
14237 crate::wire::NodeRemoveExtendedAttributeResponse,
14238 ::fidl_next::wire::fuchsia::Status,
14239 >;
14240 }
14241
14242 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
14243 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14244
14245 fn respond(response: ___R) -> Self::Output {
14246 ::core::result::Result::Ok(response)
14247 }
14248 }
14249
14250 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
14251 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14252
14253 fn respond_err(response: ___R) -> Self::Output {
14254 ::core::result::Result::Err(response)
14255 }
14256 }
14257
14258 pub struct Read;
14259
14260 impl ::fidl_next::Method for Read {
14261 const ORDINAL: u64 = 395825947633028830;
14262 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14263 ::fidl_next::protocol::Flexibility::Strict;
14264
14265 type Protocol = crate::File;
14266
14267 type Request = crate::wire::ReadableReadRequest;
14268 }
14269
14270 impl ::fidl_next::TwoWayMethod for Read {
14271 type Response = ::fidl_next::wire::Result<
14272 'static,
14273 crate::wire::ReadableReadResponse<'static>,
14274 ::fidl_next::wire::fuchsia::Status,
14275 >;
14276 }
14277
14278 impl<___R> ::fidl_next::Respond<___R> for Read {
14279 type Output = ::core::result::Result<
14280 crate::generic::ReadableReadResponse<___R>,
14281 ::fidl_next::never::Never,
14282 >;
14283
14284 fn respond(response: ___R) -> Self::Output {
14285 ::core::result::Result::Ok(crate::generic::ReadableReadResponse { data: response })
14286 }
14287 }
14288
14289 impl<___R> ::fidl_next::RespondErr<___R> for Read {
14290 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14291
14292 fn respond_err(response: ___R) -> Self::Output {
14293 ::core::result::Result::Err(response)
14294 }
14295 }
14296
14297 pub struct Write;
14298
14299 impl ::fidl_next::Method for Write {
14300 const ORDINAL: u64 = 7651971425397809026;
14301 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14302 ::fidl_next::protocol::Flexibility::Strict;
14303
14304 type Protocol = crate::File;
14305
14306 type Request = crate::wire::WritableWriteRequest<'static>;
14307 }
14308
14309 impl ::fidl_next::TwoWayMethod for Write {
14310 type Response = ::fidl_next::wire::Result<
14311 'static,
14312 crate::wire::WritableWriteResponse,
14313 ::fidl_next::wire::fuchsia::Status,
14314 >;
14315 }
14316
14317 impl<___R> ::fidl_next::Respond<___R> for Write {
14318 type Output = ::core::result::Result<
14319 crate::generic::WritableWriteResponse<___R>,
14320 ::fidl_next::never::Never,
14321 >;
14322
14323 fn respond(response: ___R) -> Self::Output {
14324 ::core::result::Result::Ok(crate::generic::WritableWriteResponse {
14325 actual_count: response,
14326 })
14327 }
14328 }
14329
14330 impl<___R> ::fidl_next::RespondErr<___R> for Write {
14331 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14332
14333 fn respond_err(response: ___R) -> Self::Output {
14334 ::core::result::Result::Err(response)
14335 }
14336 }
14337
14338 pub struct Describe;
14339
14340 impl ::fidl_next::Method for Describe {
14341 const ORDINAL: u64 = 7545125870053689020;
14342 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14343 ::fidl_next::protocol::Flexibility::Strict;
14344
14345 type Protocol = crate::File;
14346
14347 type Request = ::fidl_next::wire::EmptyMessageBody;
14348 }
14349
14350 impl ::fidl_next::TwoWayMethod for Describe {
14351 type Response = ::fidl_next::wire::Strict<crate::wire::FileInfo<'static>>;
14352 }
14353
14354 impl<___R> ::fidl_next::Respond<___R> for Describe {
14355 type Output = ::fidl_next::Strict<___R>;
14356
14357 fn respond(response: ___R) -> Self::Output {
14358 ::fidl_next::Strict(response)
14359 }
14360 }
14361
14362 pub struct Seek;
14363
14364 impl ::fidl_next::Method for Seek {
14365 const ORDINAL: u64 = 8649041485622956551;
14366 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14367 ::fidl_next::protocol::Flexibility::Strict;
14368
14369 type Protocol = crate::File;
14370
14371 type Request = crate::wire::FileSeekRequest;
14372 }
14373
14374 impl ::fidl_next::TwoWayMethod for Seek {
14375 type Response = ::fidl_next::wire::Result<
14376 'static,
14377 crate::wire::FileSeekResponse,
14378 ::fidl_next::wire::fuchsia::Status,
14379 >;
14380 }
14381
14382 impl<___R> ::fidl_next::Respond<___R> for Seek {
14383 type Output = ::core::result::Result<
14384 crate::generic::FileSeekResponse<___R>,
14385 ::fidl_next::never::Never,
14386 >;
14387
14388 fn respond(response: ___R) -> Self::Output {
14389 ::core::result::Result::Ok(crate::generic::FileSeekResponse {
14390 offset_from_start: response,
14391 })
14392 }
14393 }
14394
14395 impl<___R> ::fidl_next::RespondErr<___R> for Seek {
14396 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14397
14398 fn respond_err(response: ___R) -> Self::Output {
14399 ::core::result::Result::Err(response)
14400 }
14401 }
14402
14403 pub struct ReadAt;
14404
14405 impl ::fidl_next::Method for ReadAt {
14406 const ORDINAL: u64 = 1587416148701180478;
14407 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14408 ::fidl_next::protocol::Flexibility::Strict;
14409
14410 type Protocol = crate::File;
14411
14412 type Request = crate::wire::FileReadAtRequest;
14413 }
14414
14415 impl ::fidl_next::TwoWayMethod for ReadAt {
14416 type Response = ::fidl_next::wire::Result<
14417 'static,
14418 crate::wire::FileReadAtResponse<'static>,
14419 ::fidl_next::wire::fuchsia::Status,
14420 >;
14421 }
14422
14423 impl<___R> ::fidl_next::Respond<___R> for ReadAt {
14424 type Output = ::core::result::Result<
14425 crate::generic::FileReadAtResponse<___R>,
14426 ::fidl_next::never::Never,
14427 >;
14428
14429 fn respond(response: ___R) -> Self::Output {
14430 ::core::result::Result::Ok(crate::generic::FileReadAtResponse { data: response })
14431 }
14432 }
14433
14434 impl<___R> ::fidl_next::RespondErr<___R> for ReadAt {
14435 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14436
14437 fn respond_err(response: ___R) -> Self::Output {
14438 ::core::result::Result::Err(response)
14439 }
14440 }
14441
14442 pub struct WriteAt;
14443
14444 impl ::fidl_next::Method for WriteAt {
14445 const ORDINAL: u64 = 8736683935131400491;
14446 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14447 ::fidl_next::protocol::Flexibility::Strict;
14448
14449 type Protocol = crate::File;
14450
14451 type Request = crate::wire::FileWriteAtRequest<'static>;
14452 }
14453
14454 impl ::fidl_next::TwoWayMethod for WriteAt {
14455 type Response = ::fidl_next::wire::Result<
14456 'static,
14457 crate::wire::FileWriteAtResponse,
14458 ::fidl_next::wire::fuchsia::Status,
14459 >;
14460 }
14461
14462 impl<___R> ::fidl_next::Respond<___R> for WriteAt {
14463 type Output = ::core::result::Result<
14464 crate::generic::FileWriteAtResponse<___R>,
14465 ::fidl_next::never::Never,
14466 >;
14467
14468 fn respond(response: ___R) -> Self::Output {
14469 ::core::result::Result::Ok(crate::generic::FileWriteAtResponse {
14470 actual_count: response,
14471 })
14472 }
14473 }
14474
14475 impl<___R> ::fidl_next::RespondErr<___R> for WriteAt {
14476 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14477
14478 fn respond_err(response: ___R) -> Self::Output {
14479 ::core::result::Result::Err(response)
14480 }
14481 }
14482
14483 pub struct Resize;
14484
14485 impl ::fidl_next::Method for Resize {
14486 const ORDINAL: u64 = 3134648685270758458;
14487 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14488 ::fidl_next::protocol::Flexibility::Strict;
14489
14490 type Protocol = crate::File;
14491
14492 type Request = crate::wire::FileResizeRequest;
14493 }
14494
14495 impl ::fidl_next::TwoWayMethod for Resize {
14496 type Response = ::fidl_next::wire::Result<
14497 'static,
14498 crate::wire::FileResizeResponse,
14499 ::fidl_next::wire::fuchsia::Status,
14500 >;
14501 }
14502
14503 impl<___R> ::fidl_next::Respond<___R> for Resize {
14504 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14505
14506 fn respond(response: ___R) -> Self::Output {
14507 ::core::result::Result::Ok(response)
14508 }
14509 }
14510
14511 impl<___R> ::fidl_next::RespondErr<___R> for Resize {
14512 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14513
14514 fn respond_err(response: ___R) -> Self::Output {
14515 ::core::result::Result::Err(response)
14516 }
14517 }
14518
14519 pub struct GetBackingMemory;
14520
14521 impl ::fidl_next::Method for GetBackingMemory {
14522 const ORDINAL: u64 = 46911652864194091;
14523 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14524 ::fidl_next::protocol::Flexibility::Strict;
14525
14526 type Protocol = crate::File;
14527
14528 type Request = crate::wire::FileGetBackingMemoryRequest;
14529 }
14530
14531 impl ::fidl_next::TwoWayMethod for GetBackingMemory {
14532 type Response = ::fidl_next::wire::Result<
14533 'static,
14534 crate::wire::FileGetBackingMemoryResponse,
14535 ::fidl_next::wire::fuchsia::Status,
14536 >;
14537 }
14538
14539 impl<___R> ::fidl_next::Respond<___R> for GetBackingMemory {
14540 type Output = ::core::result::Result<
14541 crate::generic::FileGetBackingMemoryResponse<___R>,
14542 ::fidl_next::never::Never,
14543 >;
14544
14545 fn respond(response: ___R) -> Self::Output {
14546 ::core::result::Result::Ok(crate::generic::FileGetBackingMemoryResponse {
14547 vmo: response,
14548 })
14549 }
14550 }
14551
14552 impl<___R> ::fidl_next::RespondErr<___R> for GetBackingMemory {
14553 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14554
14555 fn respond_err(response: ___R) -> Self::Output {
14556 ::core::result::Result::Err(response)
14557 }
14558 }
14559
14560 pub struct Allocate;
14561
14562 impl ::fidl_next::Method for Allocate {
14563 const ORDINAL: u64 = 8645235848064269614;
14564 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14565 ::fidl_next::protocol::Flexibility::Flexible;
14566
14567 type Protocol = crate::File;
14568
14569 type Request = crate::wire::FileAllocateRequest;
14570 }
14571
14572 impl ::fidl_next::TwoWayMethod for Allocate {
14573 type Response = ::fidl_next::wire::Result<
14574 'static,
14575 crate::wire::FileAllocateResponse,
14576 ::fidl_next::wire::fuchsia::Status,
14577 >;
14578 }
14579
14580 impl<___R> ::fidl_next::Respond<___R> for Allocate {
14581 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14582
14583 fn respond(response: ___R) -> Self::Output {
14584 ::core::result::Result::Ok(response)
14585 }
14586 }
14587
14588 impl<___R> ::fidl_next::RespondErr<___R> for Allocate {
14589 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14590
14591 fn respond_err(response: ___R) -> Self::Output {
14592 ::core::result::Result::Err(response)
14593 }
14594 }
14595
14596 pub struct EnableVerity;
14597
14598 impl ::fidl_next::Method for EnableVerity {
14599 const ORDINAL: u64 = 3189145313204943035;
14600 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
14601 ::fidl_next::protocol::Flexibility::Flexible;
14602
14603 type Protocol = crate::File;
14604
14605 type Request = crate::wire::FileEnableVerityRequest<'static>;
14606 }
14607
14608 impl ::fidl_next::TwoWayMethod for EnableVerity {
14609 type Response = ::fidl_next::wire::Result<
14610 'static,
14611 crate::wire::FileEnableVerityResponse,
14612 ::fidl_next::wire::fuchsia::Status,
14613 >;
14614 }
14615
14616 impl<___R> ::fidl_next::Respond<___R> for EnableVerity {
14617 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
14618
14619 fn respond(response: ___R) -> Self::Output {
14620 ::core::result::Result::Ok(response)
14621 }
14622 }
14623
14624 impl<___R> ::fidl_next::RespondErr<___R> for EnableVerity {
14625 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
14626
14627 fn respond_err(response: ___R) -> Self::Output {
14628 ::core::result::Result::Err(response)
14629 }
14630 }
14631
14632 mod ___detail {
14633 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::File
14634 where
14635 ___T: ::fidl_next::Transport,
14636 {
14637 type Client = FileClient<___T>;
14638 type Server = FileServer<___T>;
14639 }
14640
14641 #[repr(transparent)]
14643 pub struct FileClient<___T: ::fidl_next::Transport> {
14644 #[allow(dead_code)]
14645 client: ::fidl_next::protocol::Client<___T>,
14646 }
14647
14648 impl<___T> FileClient<___T>
14649 where
14650 ___T: ::fidl_next::Transport,
14651 {
14652 #[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"]
14653 pub fn advisory_lock(
14654 &self,
14655
14656 request: impl ::fidl_next::Encode<
14657 crate::wire::AdvisoryLockRequest<'static>,
14658 <___T as ::fidl_next::Transport>::SendBuffer,
14659 >,
14660 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14661 where
14662 <___T as ::fidl_next::Transport>::SendBuffer:
14663 ::fidl_next::encoder::InternalHandleEncoder,
14664 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14665 {
14666 self.advisory_lock_with(crate::generic::AdvisoryLockingAdvisoryLockRequest {
14667 request,
14668 })
14669 }
14670
14671 #[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"]
14672 pub fn advisory_lock_with<___R>(
14673 &self,
14674 request: ___R,
14675 ) -> ::fidl_next::TwoWayFuture<'_, super::AdvisoryLock, ___T>
14676 where
14677 ___R: ::fidl_next::Encode<
14678 crate::wire::AdvisoryLockingAdvisoryLockRequest<'static>,
14679 <___T as ::fidl_next::Transport>::SendBuffer,
14680 >,
14681 {
14682 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14683 7992130864415541162,
14684 <super::AdvisoryLock as ::fidl_next::Method>::FLEXIBILITY,
14685 request,
14686 ))
14687 }
14688
14689 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
14690 pub fn link_into(
14691 &self,
14692
14693 dst_parent_token: impl ::fidl_next::Encode<
14694 ::fidl_next::wire::fuchsia::Event,
14695 <___T as ::fidl_next::Transport>::SendBuffer,
14696 >,
14697
14698 dst: impl ::fidl_next::Encode<
14699 ::fidl_next::wire::String<'static>,
14700 <___T as ::fidl_next::Transport>::SendBuffer,
14701 >,
14702 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14703 where
14704 <___T as ::fidl_next::Transport>::SendBuffer:
14705 ::fidl_next::encoder::InternalHandleEncoder,
14706 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
14707 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14708 {
14709 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
14710 dst_parent_token,
14711
14712 dst,
14713 })
14714 }
14715
14716 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
14717 pub fn link_into_with<___R>(
14718 &self,
14719 request: ___R,
14720 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
14721 where
14722 ___R: ::fidl_next::Encode<
14723 crate::wire::LinkableLinkIntoRequest<'static>,
14724 <___T as ::fidl_next::Transport>::SendBuffer,
14725 >,
14726 {
14727 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14728 6121399674497678964,
14729 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
14730 request,
14731 ))
14732 }
14733
14734 pub fn clone(
14735 &self,
14736
14737 request: impl ::fidl_next::Encode<
14738 ::fidl_next::ServerEnd<
14739 ::fidl_next_fuchsia_unknown::Cloneable,
14740 ::fidl_next::wire::fuchsia::Channel,
14741 >,
14742 <___T as ::fidl_next::Transport>::SendBuffer,
14743 >,
14744 ) -> ::fidl_next::SendFuture<'_, ___T>
14745 where
14746 <___T as ::fidl_next::Transport>::SendBuffer:
14747 ::fidl_next::encoder::InternalHandleEncoder,
14748 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
14749 {
14750 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
14751 request,
14752 })
14753 }
14754
14755 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
14756 where
14757 ___R: ::fidl_next::Encode<
14758 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
14759 <___T as ::fidl_next::Transport>::SendBuffer,
14760 >,
14761 {
14762 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
14763 2366825959783828089,
14764 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
14765 request,
14766 ))
14767 }
14768
14769 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
14770 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
14771 ::fidl_next::TwoWayFuture::from_untyped(
14772 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14773 6540867515453498750,
14774 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
14775 (),
14776 ),
14777 )
14778 }
14779
14780 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
14781 ::fidl_next::TwoWayFuture::from_untyped(
14782 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14783 2763219980499352582,
14784 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
14785 (),
14786 ),
14787 )
14788 }
14789
14790 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14791 pub fn deprecated_get_attr(
14792 &self,
14793 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
14794 ::fidl_next::TwoWayFuture::from_untyped(
14795 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14796 8689798978500614909,
14797 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
14798 (),
14799 ),
14800 )
14801 }
14802
14803 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14804 pub fn deprecated_set_attr(
14805 &self,
14806
14807 flags: impl ::fidl_next::Encode<
14808 crate::wire::NodeAttributeFlags,
14809 <___T as ::fidl_next::Transport>::SendBuffer,
14810 >,
14811
14812 attributes: impl ::fidl_next::Encode<
14813 crate::wire::NodeAttributes,
14814 <___T as ::fidl_next::Transport>::SendBuffer,
14815 >,
14816 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14817 where
14818 <___T as ::fidl_next::Transport>::SendBuffer:
14819 ::fidl_next::encoder::InternalHandleEncoder,
14820 {
14821 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
14822 flags,
14823
14824 attributes,
14825 })
14826 }
14827
14828 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
14829 pub fn deprecated_set_attr_with<___R>(
14830 &self,
14831 request: ___R,
14832 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
14833 where
14834 ___R: ::fidl_next::Encode<
14835 crate::wire::NodeDeprecatedSetAttrRequest,
14836 <___T as ::fidl_next::Transport>::SendBuffer,
14837 >,
14838 {
14839 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14840 4721673413776871238,
14841 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
14842 request,
14843 ))
14844 }
14845
14846 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
14847 pub fn deprecated_get_flags(
14848 &self,
14849 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
14850 ::fidl_next::TwoWayFuture::from_untyped(
14851 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14852 6595803110182632097,
14853 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
14854 (),
14855 ),
14856 )
14857 }
14858
14859 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14860 pub fn deprecated_set_flags(
14861 &self,
14862
14863 flags: impl ::fidl_next::Encode<
14864 crate::wire::OpenFlags,
14865 <___T as ::fidl_next::Transport>::SendBuffer,
14866 >,
14867 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14868 where
14869 <___T as ::fidl_next::Transport>::SendBuffer:
14870 ::fidl_next::encoder::InternalHandleEncoder,
14871 {
14872 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
14873 flags,
14874 })
14875 }
14876
14877 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
14878 pub fn deprecated_set_flags_with<___R>(
14879 &self,
14880 request: ___R,
14881 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
14882 where
14883 ___R: ::fidl_next::Encode<
14884 crate::wire::NodeDeprecatedSetFlagsRequest,
14885 <___T as ::fidl_next::Transport>::SendBuffer,
14886 >,
14887 {
14888 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14889 5950864159036794675,
14890 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
14891 request,
14892 ))
14893 }
14894
14895 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
14896 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
14897 ::fidl_next::TwoWayFuture::from_untyped(
14898 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14899 105530239381466147,
14900 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
14901 (),
14902 ),
14903 )
14904 }
14905
14906 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
14907 pub fn set_flags(
14908 &self,
14909
14910 flags: impl ::fidl_next::Encode<
14911 crate::wire::Flags,
14912 <___T as ::fidl_next::Transport>::SendBuffer,
14913 >,
14914 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14915 where
14916 <___T as ::fidl_next::Transport>::SendBuffer:
14917 ::fidl_next::encoder::InternalHandleEncoder,
14918 {
14919 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
14920 }
14921
14922 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
14923 pub fn set_flags_with<___R>(
14924 &self,
14925 request: ___R,
14926 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
14927 where
14928 ___R: ::fidl_next::Encode<
14929 crate::wire::NodeSetFlagsRequest,
14930 <___T as ::fidl_next::Transport>::SendBuffer,
14931 >,
14932 {
14933 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14934 6172186066099445416,
14935 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
14936 request,
14937 ))
14938 }
14939
14940 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
14941 pub fn query_filesystem(
14942 &self,
14943 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
14944 ::fidl_next::TwoWayFuture::from_untyped(
14945 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14946 8013111122914313744,
14947 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
14948 (),
14949 ),
14950 )
14951 }
14952
14953 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
14954 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
14955 ::fidl_next::TwoWayFuture::from_untyped(
14956 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
14957 5788516050773961964,
14958 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
14959 (),
14960 ),
14961 )
14962 }
14963
14964 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14965 pub fn get_attributes(
14966 &self,
14967
14968 query: impl ::fidl_next::Encode<
14969 crate::wire::NodeAttributesQuery,
14970 <___T as ::fidl_next::Transport>::SendBuffer,
14971 >,
14972 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14973 where
14974 <___T as ::fidl_next::Transport>::SendBuffer:
14975 ::fidl_next::encoder::InternalHandleEncoder,
14976 {
14977 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
14978 }
14979
14980 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
14981 pub fn get_attributes_with<___R>(
14982 &self,
14983 request: ___R,
14984 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
14985 where
14986 ___R: ::fidl_next::Encode<
14987 crate::wire::NodeGetAttributesRequest,
14988 <___T as ::fidl_next::Transport>::SendBuffer,
14989 >,
14990 {
14991 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
14992 4414537700416816443,
14993 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
14994 request,
14995 ))
14996 }
14997
14998 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
14999 pub fn update_attributes_with<___R>(
15000 &self,
15001 request: ___R,
15002 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
15003 where
15004 ___R: ::fidl_next::Encode<
15005 crate::wire::MutableNodeAttributes<'static>,
15006 <___T as ::fidl_next::Transport>::SendBuffer,
15007 >,
15008 {
15009 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15010 3677402239314018056,
15011 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
15012 request,
15013 ))
15014 }
15015
15016 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
15017 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
15018 ::fidl_next::TwoWayFuture::from_untyped(
15019 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
15020 3196473584242777161,
15021 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
15022 (),
15023 ),
15024 )
15025 }
15026
15027 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15028 pub fn list_extended_attributes(
15029 &self,
15030
15031 iterator: impl ::fidl_next::Encode<
15032 ::fidl_next::ServerEnd<
15033 crate::ExtendedAttributeIterator,
15034 ::fidl_next::wire::fuchsia::Channel,
15035 >,
15036 <___T as ::fidl_next::Transport>::SendBuffer,
15037 >,
15038 ) -> ::fidl_next::SendFuture<'_, ___T>
15039 where
15040 <___T as ::fidl_next::Transport>::SendBuffer:
15041 ::fidl_next::encoder::InternalHandleEncoder,
15042 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15043 {
15044 self.list_extended_attributes_with(
15045 crate::generic::NodeListExtendedAttributesRequest { iterator },
15046 )
15047 }
15048
15049 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15050 pub fn list_extended_attributes_with<___R>(
15051 &self,
15052 request: ___R,
15053 ) -> ::fidl_next::SendFuture<'_, ___T>
15054 where
15055 ___R: ::fidl_next::Encode<
15056 crate::wire::NodeListExtendedAttributesRequest,
15057 <___T as ::fidl_next::Transport>::SendBuffer,
15058 >,
15059 {
15060 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
15061 5431626189872037072,
15062 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
15063 request,
15064 ))
15065 }
15066
15067 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15068 pub fn get_extended_attribute(
15069 &self,
15070
15071 name: impl ::fidl_next::Encode<
15072 ::fidl_next::wire::Vector<'static, u8>,
15073 <___T as ::fidl_next::Transport>::SendBuffer,
15074 >,
15075 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
15076 where
15077 <___T as ::fidl_next::Transport>::SendBuffer:
15078 ::fidl_next::encoder::InternalHandleEncoder,
15079 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15080 {
15081 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
15082 name,
15083 })
15084 }
15085
15086 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15087 pub fn get_extended_attribute_with<___R>(
15088 &self,
15089 request: ___R,
15090 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
15091 where
15092 ___R: ::fidl_next::Encode<
15093 crate::wire::NodeGetExtendedAttributeRequest<'static>,
15094 <___T as ::fidl_next::Transport>::SendBuffer,
15095 >,
15096 {
15097 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15098 5043930208506967771,
15099 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15100 request,
15101 ))
15102 }
15103
15104 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15105 pub fn set_extended_attribute(
15106 &self,
15107
15108 name: impl ::fidl_next::Encode<
15109 ::fidl_next::wire::Vector<'static, u8>,
15110 <___T as ::fidl_next::Transport>::SendBuffer,
15111 >,
15112
15113 value: impl ::fidl_next::Encode<
15114 crate::wire::ExtendedAttributeValue<'static>,
15115 <___T as ::fidl_next::Transport>::SendBuffer,
15116 >,
15117
15118 mode: impl ::fidl_next::Encode<
15119 crate::wire::SetExtendedAttributeMode,
15120 <___T as ::fidl_next::Transport>::SendBuffer,
15121 >,
15122 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
15123 where
15124 <___T as ::fidl_next::Transport>::SendBuffer:
15125 ::fidl_next::encoder::InternalHandleEncoder,
15126 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15127 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15128 {
15129 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
15130 name,
15131
15132 value,
15133
15134 mode,
15135 })
15136 }
15137
15138 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15139 pub fn set_extended_attribute_with<___R>(
15140 &self,
15141 request: ___R,
15142 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
15143 where
15144 ___R: ::fidl_next::Encode<
15145 crate::wire::NodeSetExtendedAttributeRequest<'static>,
15146 <___T as ::fidl_next::Transport>::SendBuffer,
15147 >,
15148 {
15149 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15150 5374223046099989052,
15151 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15152 request,
15153 ))
15154 }
15155
15156 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15157 pub fn remove_extended_attribute(
15158 &self,
15159
15160 name: impl ::fidl_next::Encode<
15161 ::fidl_next::wire::Vector<'static, u8>,
15162 <___T as ::fidl_next::Transport>::SendBuffer,
15163 >,
15164 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
15165 where
15166 <___T as ::fidl_next::Transport>::SendBuffer:
15167 ::fidl_next::encoder::InternalHandleEncoder,
15168 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15169 {
15170 self.remove_extended_attribute_with(
15171 crate::generic::NodeRemoveExtendedAttributeRequest { name },
15172 )
15173 }
15174
15175 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15176 pub fn remove_extended_attribute_with<___R>(
15177 &self,
15178 request: ___R,
15179 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
15180 where
15181 ___R: ::fidl_next::Encode<
15182 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
15183 <___T as ::fidl_next::Transport>::SendBuffer,
15184 >,
15185 {
15186 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15187 8794297771444732717,
15188 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
15189 request,
15190 ))
15191 }
15192
15193 #[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"]
15194 pub fn read(
15195 &self,
15196
15197 count: impl ::fidl_next::Encode<
15198 ::fidl_next::wire::Uint64,
15199 <___T as ::fidl_next::Transport>::SendBuffer,
15200 >,
15201 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
15202 where
15203 <___T as ::fidl_next::Transport>::SendBuffer:
15204 ::fidl_next::encoder::InternalHandleEncoder,
15205 {
15206 self.read_with(crate::generic::ReadableReadRequest { count })
15207 }
15208
15209 #[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"]
15210 pub fn read_with<___R>(
15211 &self,
15212 request: ___R,
15213 ) -> ::fidl_next::TwoWayFuture<'_, super::Read, ___T>
15214 where
15215 ___R: ::fidl_next::Encode<
15216 crate::wire::ReadableReadRequest,
15217 <___T as ::fidl_next::Transport>::SendBuffer,
15218 >,
15219 {
15220 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15221 395825947633028830,
15222 <super::Read as ::fidl_next::Method>::FLEXIBILITY,
15223 request,
15224 ))
15225 }
15226
15227 #[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"]
15228 pub fn write(
15229 &self,
15230
15231 data: impl ::fidl_next::Encode<
15232 ::fidl_next::wire::Vector<'static, u8>,
15233 <___T as ::fidl_next::Transport>::SendBuffer,
15234 >,
15235 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
15236 where
15237 <___T as ::fidl_next::Transport>::SendBuffer:
15238 ::fidl_next::encoder::InternalHandleEncoder,
15239 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15240 {
15241 self.write_with(crate::generic::WritableWriteRequest { data })
15242 }
15243
15244 #[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"]
15245 pub fn write_with<___R>(
15246 &self,
15247 request: ___R,
15248 ) -> ::fidl_next::TwoWayFuture<'_, super::Write, ___T>
15249 where
15250 ___R: ::fidl_next::Encode<
15251 crate::wire::WritableWriteRequest<'static>,
15252 <___T as ::fidl_next::Transport>::SendBuffer,
15253 >,
15254 {
15255 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15256 7651971425397809026,
15257 <super::Write as ::fidl_next::Method>::FLEXIBILITY,
15258 request,
15259 ))
15260 }
15261
15262 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
15263 ::fidl_next::TwoWayFuture::from_untyped(
15264 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
15265 7545125870053689020,
15266 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
15267 (),
15268 ),
15269 )
15270 }
15271
15272 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
15273 pub fn seek(
15274 &self,
15275
15276 origin: impl ::fidl_next::Encode<
15277 crate::wire::SeekOrigin,
15278 <___T as ::fidl_next::Transport>::SendBuffer,
15279 >,
15280
15281 offset: impl ::fidl_next::Encode<
15282 ::fidl_next::wire::Int64,
15283 <___T as ::fidl_next::Transport>::SendBuffer,
15284 >,
15285 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
15286 where
15287 <___T as ::fidl_next::Transport>::SendBuffer:
15288 ::fidl_next::encoder::InternalHandleEncoder,
15289 {
15290 self.seek_with(crate::generic::FileSeekRequest { origin, offset })
15291 }
15292
15293 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
15294 pub fn seek_with<___R>(
15295 &self,
15296 request: ___R,
15297 ) -> ::fidl_next::TwoWayFuture<'_, super::Seek, ___T>
15298 where
15299 ___R: ::fidl_next::Encode<
15300 crate::wire::FileSeekRequest,
15301 <___T as ::fidl_next::Transport>::SendBuffer,
15302 >,
15303 {
15304 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15305 8649041485622956551,
15306 <super::Seek as ::fidl_next::Method>::FLEXIBILITY,
15307 request,
15308 ))
15309 }
15310
15311 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
15312 pub fn read_at(
15313 &self,
15314
15315 count: impl ::fidl_next::Encode<
15316 ::fidl_next::wire::Uint64,
15317 <___T as ::fidl_next::Transport>::SendBuffer,
15318 >,
15319
15320 offset: impl ::fidl_next::Encode<
15321 ::fidl_next::wire::Uint64,
15322 <___T as ::fidl_next::Transport>::SendBuffer,
15323 >,
15324 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
15325 where
15326 <___T as ::fidl_next::Transport>::SendBuffer:
15327 ::fidl_next::encoder::InternalHandleEncoder,
15328 {
15329 self.read_at_with(crate::generic::FileReadAtRequest { count, offset })
15330 }
15331
15332 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
15333 pub fn read_at_with<___R>(
15334 &self,
15335 request: ___R,
15336 ) -> ::fidl_next::TwoWayFuture<'_, super::ReadAt, ___T>
15337 where
15338 ___R: ::fidl_next::Encode<
15339 crate::wire::FileReadAtRequest,
15340 <___T as ::fidl_next::Transport>::SendBuffer,
15341 >,
15342 {
15343 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15344 1587416148701180478,
15345 <super::ReadAt as ::fidl_next::Method>::FLEXIBILITY,
15346 request,
15347 ))
15348 }
15349
15350 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15351 pub fn write_at(
15352 &self,
15353
15354 data: impl ::fidl_next::Encode<
15355 ::fidl_next::wire::Vector<'static, u8>,
15356 <___T as ::fidl_next::Transport>::SendBuffer,
15357 >,
15358
15359 offset: impl ::fidl_next::Encode<
15360 ::fidl_next::wire::Uint64,
15361 <___T as ::fidl_next::Transport>::SendBuffer,
15362 >,
15363 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
15364 where
15365 <___T as ::fidl_next::Transport>::SendBuffer:
15366 ::fidl_next::encoder::InternalHandleEncoder,
15367 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15368 {
15369 self.write_at_with(crate::generic::FileWriteAtRequest { data, offset })
15370 }
15371
15372 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15373 pub fn write_at_with<___R>(
15374 &self,
15375 request: ___R,
15376 ) -> ::fidl_next::TwoWayFuture<'_, super::WriteAt, ___T>
15377 where
15378 ___R: ::fidl_next::Encode<
15379 crate::wire::FileWriteAtRequest<'static>,
15380 <___T as ::fidl_next::Transport>::SendBuffer,
15381 >,
15382 {
15383 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15384 8736683935131400491,
15385 <super::WriteAt as ::fidl_next::Method>::FLEXIBILITY,
15386 request,
15387 ))
15388 }
15389
15390 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15391 pub fn resize(
15392 &self,
15393
15394 length: impl ::fidl_next::Encode<
15395 ::fidl_next::wire::Uint64,
15396 <___T as ::fidl_next::Transport>::SendBuffer,
15397 >,
15398 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
15399 where
15400 <___T as ::fidl_next::Transport>::SendBuffer:
15401 ::fidl_next::encoder::InternalHandleEncoder,
15402 {
15403 self.resize_with(crate::generic::FileResizeRequest { length })
15404 }
15405
15406 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15407 pub fn resize_with<___R>(
15408 &self,
15409 request: ___R,
15410 ) -> ::fidl_next::TwoWayFuture<'_, super::Resize, ___T>
15411 where
15412 ___R: ::fidl_next::Encode<
15413 crate::wire::FileResizeRequest,
15414 <___T as ::fidl_next::Transport>::SendBuffer,
15415 >,
15416 {
15417 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15418 3134648685270758458,
15419 <super::Resize as ::fidl_next::Method>::FLEXIBILITY,
15420 request,
15421 ))
15422 }
15423
15424 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
15425 pub fn get_backing_memory(
15426 &self,
15427
15428 flags: impl ::fidl_next::Encode<
15429 crate::wire::VmoFlags,
15430 <___T as ::fidl_next::Transport>::SendBuffer,
15431 >,
15432 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
15433 where
15434 <___T as ::fidl_next::Transport>::SendBuffer:
15435 ::fidl_next::encoder::InternalHandleEncoder,
15436 {
15437 self.get_backing_memory_with(crate::generic::FileGetBackingMemoryRequest { flags })
15438 }
15439
15440 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
15441 pub fn get_backing_memory_with<___R>(
15442 &self,
15443 request: ___R,
15444 ) -> ::fidl_next::TwoWayFuture<'_, super::GetBackingMemory, ___T>
15445 where
15446 ___R: ::fidl_next::Encode<
15447 crate::wire::FileGetBackingMemoryRequest,
15448 <___T as ::fidl_next::Transport>::SendBuffer,
15449 >,
15450 {
15451 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15452 46911652864194091,
15453 <super::GetBackingMemory as ::fidl_next::Method>::FLEXIBILITY,
15454 request,
15455 ))
15456 }
15457
15458 #[doc = " Pre-allocate on-disk space for this file.\n"]
15459 pub fn allocate(
15460 &self,
15461
15462 offset: impl ::fidl_next::Encode<
15463 ::fidl_next::wire::Uint64,
15464 <___T as ::fidl_next::Transport>::SendBuffer,
15465 >,
15466
15467 length: impl ::fidl_next::Encode<
15468 ::fidl_next::wire::Uint64,
15469 <___T as ::fidl_next::Transport>::SendBuffer,
15470 >,
15471
15472 mode: impl ::fidl_next::Encode<
15473 crate::wire::AllocateMode,
15474 <___T as ::fidl_next::Transport>::SendBuffer,
15475 >,
15476 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
15477 where
15478 <___T as ::fidl_next::Transport>::SendBuffer:
15479 ::fidl_next::encoder::InternalHandleEncoder,
15480 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15481 {
15482 self.allocate_with(crate::generic::FileAllocateRequest { offset, length, mode })
15483 }
15484
15485 #[doc = " Pre-allocate on-disk space for this file.\n"]
15486 pub fn allocate_with<___R>(
15487 &self,
15488 request: ___R,
15489 ) -> ::fidl_next::TwoWayFuture<'_, super::Allocate, ___T>
15490 where
15491 ___R: ::fidl_next::Encode<
15492 crate::wire::FileAllocateRequest,
15493 <___T as ::fidl_next::Transport>::SendBuffer,
15494 >,
15495 {
15496 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15497 8645235848064269614,
15498 <super::Allocate as ::fidl_next::Method>::FLEXIBILITY,
15499 request,
15500 ))
15501 }
15502
15503 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
15504 pub fn enable_verity(
15505 &self,
15506
15507 options: impl ::fidl_next::Encode<
15508 crate::wire::VerificationOptions<'static>,
15509 <___T as ::fidl_next::Transport>::SendBuffer,
15510 >,
15511 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
15512 where
15513 <___T as ::fidl_next::Transport>::SendBuffer:
15514 ::fidl_next::encoder::InternalHandleEncoder,
15515 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15516 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15517 {
15518 self.enable_verity_with(crate::generic::FileEnableVerityRequest { options })
15519 }
15520
15521 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
15522 pub fn enable_verity_with<___R>(
15523 &self,
15524 request: ___R,
15525 ) -> ::fidl_next::TwoWayFuture<'_, super::EnableVerity, ___T>
15526 where
15527 ___R: ::fidl_next::Encode<
15528 crate::wire::FileEnableVerityRequest<'static>,
15529 <___T as ::fidl_next::Transport>::SendBuffer,
15530 >,
15531 {
15532 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
15533 3189145313204943035,
15534 <super::EnableVerity as ::fidl_next::Method>::FLEXIBILITY,
15535 request,
15536 ))
15537 }
15538 }
15539
15540 #[repr(transparent)]
15542 pub struct FileServer<___T: ::fidl_next::Transport> {
15543 server: ::fidl_next::protocol::Server<___T>,
15544 }
15545
15546 impl<___T> FileServer<___T>
15547 where
15548 ___T: ::fidl_next::Transport,
15549 {
15550 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
15551 pub fn on_open(
15552 &self,
15553
15554 s: impl ::fidl_next::Encode<
15555 ::fidl_next::wire::fuchsia::StatusResult,
15556 <___T as ::fidl_next::Transport>::SendBuffer,
15557 >,
15558
15559 info: impl ::fidl_next::Encode<
15560 crate::wire_optional::NodeInfoDeprecated<'static>,
15561 <___T as ::fidl_next::Transport>::SendBuffer,
15562 >,
15563 ) -> ::fidl_next::SendFuture<'_, ___T>
15564 where
15565 <___T as ::fidl_next::Transport>::SendBuffer:
15566 ::fidl_next::encoder::InternalHandleEncoder,
15567 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
15568 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
15569 {
15570 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
15571 }
15572
15573 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
15574
15575 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
15576 where
15577 ___R: ::fidl_next::Encode<
15578 <super::OnOpen as ::fidl_next::Method>::Request,
15579 <___T as ::fidl_next::Transport>::SendBuffer,
15580 >,
15581 {
15582 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15583 9207534335756671346,
15584 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
15585 request,
15586 ))
15587 }
15588
15589 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
15590
15591 pub fn on_representation_with<___R>(
15592 &self,
15593 request: ___R,
15594 ) -> ::fidl_next::SendFuture<'_, ___T>
15595 where
15596 ___R: ::fidl_next::Encode<
15597 <super::OnRepresentation as ::fidl_next::Method>::Request,
15598 <___T as ::fidl_next::Transport>::SendBuffer,
15599 >,
15600 {
15601 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
15602 6679970090861613324,
15603 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
15604 request,
15605 ))
15606 }
15607 }
15608 }
15609}
15610
15611#[diagnostic::on_unimplemented(
15612 note = "If {Self} implements the non-local FileClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
15613)]
15614
15615pub trait FileLocalClientHandler<
15619 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15620 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15621>
15622{
15623 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
15624 fn on_open(
15625 &mut self,
15626
15627 request: ::fidl_next::Request<file::OnOpen, ___T>,
15628 ) -> impl ::core::future::Future<Output = ()>;
15629
15630 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
15631 fn on_representation(
15632 &mut self,
15633
15634 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
15635 ) -> impl ::core::future::Future<Output = ()>;
15636
15637 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15638 ::core::future::ready(())
15639 }
15640}
15641
15642impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for File
15643where
15644 ___H: FileLocalClientHandler<___T>,
15645 ___T: ::fidl_next::Transport,
15646 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
15647 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15648 Constraint = (),
15649 >,
15650 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
15651 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15652 Constraint = (),
15653 >,
15654{
15655 async fn on_event(
15656 handler: &mut ___H,
15657 mut message: ::fidl_next::Message<___T>,
15658 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
15659 match *message.header().ordinal {
15660 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15661 Ok(decoded) => {
15662 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
15663 Ok(())
15664 }
15665 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15666 ordinal: 9207534335756671346,
15667 error,
15668 }),
15669 },
15670
15671 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
15672 Ok(decoded) => {
15673 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
15674 Ok(())
15675 }
15676 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
15677 ordinal: 6679970090861613324,
15678 error,
15679 }),
15680 },
15681
15682 ordinal => {
15683 handler.on_unknown_interaction(ordinal).await;
15684 if ::core::matches!(
15685 message.header().flexibility(),
15686 ::fidl_next::protocol::Flexibility::Strict
15687 ) {
15688 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
15689 } else {
15690 Ok(())
15691 }
15692 }
15693 }
15694 }
15695}
15696
15697#[diagnostic::on_unimplemented(
15698 note = "If {Self} implements the non-local FileServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
15699)]
15700
15701pub trait FileLocalServerHandler<
15705 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
15706 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
15707>
15708{
15709 #[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"]
15710 fn advisory_lock(
15711 &mut self,
15712
15713 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
15714
15715 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
15716 ) -> impl ::core::future::Future<Output = ()>;
15717
15718 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
15719 fn link_into(
15720 &mut self,
15721
15722 request: ::fidl_next::Request<file::LinkInto, ___T>,
15723
15724 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
15725 ) -> impl ::core::future::Future<Output = ()>;
15726
15727 fn clone(
15728 &mut self,
15729
15730 request: ::fidl_next::Request<file::Clone, ___T>,
15731 ) -> impl ::core::future::Future<Output = ()>;
15732
15733 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
15734 fn close(
15735 &mut self,
15736
15737 responder: ::fidl_next::Responder<file::Close, ___T>,
15738 ) -> impl ::core::future::Future<Output = ()>;
15739
15740 fn query(
15741 &mut self,
15742
15743 responder: ::fidl_next::Responder<file::Query, ___T>,
15744 ) -> impl ::core::future::Future<Output = ()>;
15745
15746 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
15747 fn deprecated_get_attr(
15748 &mut self,
15749
15750 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
15751 ) -> impl ::core::future::Future<Output = ()>;
15752
15753 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
15754 fn deprecated_set_attr(
15755 &mut self,
15756
15757 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
15758
15759 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
15760 ) -> impl ::core::future::Future<Output = ()>;
15761
15762 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
15763 fn deprecated_get_flags(
15764 &mut self,
15765
15766 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
15767 ) -> impl ::core::future::Future<Output = ()>;
15768
15769 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
15770 fn deprecated_set_flags(
15771 &mut self,
15772
15773 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
15774
15775 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
15776 ) -> impl ::core::future::Future<Output = ()>;
15777
15778 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
15779 fn get_flags(
15780 &mut self,
15781
15782 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
15783 ) -> impl ::core::future::Future<Output = ()>;
15784
15785 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
15786 fn set_flags(
15787 &mut self,
15788
15789 request: ::fidl_next::Request<file::SetFlags, ___T>,
15790
15791 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
15792 ) -> impl ::core::future::Future<Output = ()>;
15793
15794 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
15795 fn query_filesystem(
15796 &mut self,
15797
15798 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
15799 ) -> impl ::core::future::Future<Output = ()>;
15800
15801 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
15802 fn get_token(
15803 &mut self,
15804
15805 responder: ::fidl_next::Responder<file::GetToken, ___T>,
15806 ) -> impl ::core::future::Future<Output = ()>;
15807
15808 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
15809 fn get_attributes(
15810 &mut self,
15811
15812 request: ::fidl_next::Request<file::GetAttributes, ___T>,
15813
15814 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
15815 ) -> impl ::core::future::Future<Output = ()>;
15816
15817 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
15818 fn update_attributes(
15819 &mut self,
15820
15821 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
15822
15823 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
15824 ) -> impl ::core::future::Future<Output = ()>;
15825
15826 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
15827 fn sync(
15828 &mut self,
15829
15830 responder: ::fidl_next::Responder<file::Sync, ___T>,
15831 ) -> impl ::core::future::Future<Output = ()>;
15832
15833 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15834 fn list_extended_attributes(
15835 &mut self,
15836
15837 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
15838 ) -> impl ::core::future::Future<Output = ()>;
15839
15840 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
15841 fn get_extended_attribute(
15842 &mut self,
15843
15844 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
15845
15846 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
15847 ) -> impl ::core::future::Future<Output = ()>;
15848
15849 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15850 fn set_extended_attribute(
15851 &mut self,
15852
15853 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
15854
15855 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
15856 ) -> impl ::core::future::Future<Output = ()>;
15857
15858 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15859 fn remove_extended_attribute(
15860 &mut self,
15861
15862 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
15863
15864 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
15865 ) -> impl ::core::future::Future<Output = ()>;
15866
15867 #[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"]
15868 fn read(
15869 &mut self,
15870
15871 request: ::fidl_next::Request<file::Read, ___T>,
15872
15873 responder: ::fidl_next::Responder<file::Read, ___T>,
15874 ) -> impl ::core::future::Future<Output = ()>;
15875
15876 #[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"]
15877 fn write(
15878 &mut self,
15879
15880 request: ::fidl_next::Request<file::Write, ___T>,
15881
15882 responder: ::fidl_next::Responder<file::Write, ___T>,
15883 ) -> impl ::core::future::Future<Output = ()>;
15884
15885 fn describe(
15886 &mut self,
15887
15888 responder: ::fidl_next::Responder<file::Describe, ___T>,
15889 ) -> impl ::core::future::Future<Output = ()>;
15890
15891 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
15892 fn seek(
15893 &mut self,
15894
15895 request: ::fidl_next::Request<file::Seek, ___T>,
15896
15897 responder: ::fidl_next::Responder<file::Seek, ___T>,
15898 ) -> impl ::core::future::Future<Output = ()>;
15899
15900 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
15901 fn read_at(
15902 &mut self,
15903
15904 request: ::fidl_next::Request<file::ReadAt, ___T>,
15905
15906 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
15907 ) -> impl ::core::future::Future<Output = ()>;
15908
15909 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15910 fn write_at(
15911 &mut self,
15912
15913 request: ::fidl_next::Request<file::WriteAt, ___T>,
15914
15915 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
15916 ) -> impl ::core::future::Future<Output = ()>;
15917
15918 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
15919 fn resize(
15920 &mut self,
15921
15922 request: ::fidl_next::Request<file::Resize, ___T>,
15923
15924 responder: ::fidl_next::Responder<file::Resize, ___T>,
15925 ) -> impl ::core::future::Future<Output = ()>;
15926
15927 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
15928 fn get_backing_memory(
15929 &mut self,
15930
15931 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
15932
15933 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
15934 ) -> impl ::core::future::Future<Output = ()>;
15935
15936 #[doc = " Pre-allocate on-disk space for this file.\n"]
15937 fn allocate(
15938 &mut self,
15939
15940 request: ::fidl_next::Request<file::Allocate, ___T>,
15941
15942 responder: ::fidl_next::Responder<file::Allocate, ___T>,
15943 ) -> impl ::core::future::Future<Output = ()>;
15944
15945 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
15946 fn enable_verity(
15947 &mut self,
15948
15949 request: ::fidl_next::Request<file::EnableVerity, ___T>,
15950
15951 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
15952 ) -> impl ::core::future::Future<Output = ()>;
15953
15954 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
15955 ::core::future::ready(())
15956 }
15957}
15958
15959impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for File
15960where
15961 ___H: FileLocalServerHandler<___T>,
15962 ___T: ::fidl_next::Transport,
15963 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
15964 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15965 Constraint = (),
15966 >,
15967 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
15968 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15969 Constraint = (),
15970 >,
15971 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
15972 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15973 Constraint = (),
15974 >,
15975 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
15976 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15977 Constraint = (),
15978 >,
15979 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
15980 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15981 Constraint = (),
15982 >,
15983 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
15984 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15985 Constraint = (),
15986 >,
15987 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
15988 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15989 Constraint = (),
15990 >,
15991 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
15992 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15993 Constraint = (),
15994 >,
15995 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
15996 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
15997 Constraint = (),
15998 >,
15999 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16000 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16001 Constraint = (),
16002 >,
16003 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16004 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16005 Constraint = (),
16006 >,
16007 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16008 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16009 Constraint = (),
16010 >,
16011 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
16012 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16013 Constraint = (),
16014 >,
16015 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
16016 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16017 Constraint = (),
16018 >,
16019 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
16020 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16021 Constraint = (),
16022 >,
16023 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16024 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16025 Constraint = (),
16026 >,
16027 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16028 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16029 Constraint = (),
16030 >,
16031 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16032 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16033 Constraint = (),
16034 >,
16035 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16036 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16037 Constraint = (),
16038 >,
16039 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16040 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16041 Constraint = (),
16042 >,
16043 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16044 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16045 Constraint = (),
16046 >,
16047{
16048 async fn on_one_way(
16049 handler: &mut ___H,
16050 mut message: ::fidl_next::Message<___T>,
16051 ) -> ::core::result::Result<
16052 (),
16053 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16054 > {
16055 match *message.header().ordinal {
16056 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16057 Ok(decoded) => {
16058 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
16059 Ok(())
16060 }
16061 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16062 ordinal: 2366825959783828089,
16063 error,
16064 }),
16065 },
16066
16067 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16068 Ok(decoded) => {
16069 handler
16070 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
16071 .await;
16072 Ok(())
16073 }
16074 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16075 ordinal: 5431626189872037072,
16076 error,
16077 }),
16078 },
16079
16080 ordinal => {
16081 handler.on_unknown_interaction(ordinal).await;
16082 if ::core::matches!(
16083 message.header().flexibility(),
16084 ::fidl_next::protocol::Flexibility::Strict
16085 ) {
16086 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16087 } else {
16088 Ok(())
16089 }
16090 }
16091 }
16092 }
16093
16094 async fn on_two_way(
16095 handler: &mut ___H,
16096 mut message: ::fidl_next::Message<___T>,
16097 responder: ::fidl_next::protocol::Responder<___T>,
16098 ) -> ::core::result::Result<
16099 (),
16100 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16101 > {
16102 match *message.header().ordinal {
16103 7992130864415541162 => {
16104 let responder = ::fidl_next::Responder::from_untyped(responder);
16105
16106 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16107 Ok(decoded) => {
16108 handler
16109 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
16110 .await;
16111 Ok(())
16112 }
16113 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16114 ordinal: 7992130864415541162,
16115 error,
16116 }),
16117 }
16118 }
16119
16120 6121399674497678964 => {
16121 let responder = ::fidl_next::Responder::from_untyped(responder);
16122
16123 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16124 Ok(decoded) => {
16125 handler
16126 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
16127 .await;
16128 Ok(())
16129 }
16130 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16131 ordinal: 6121399674497678964,
16132 error,
16133 }),
16134 }
16135 }
16136
16137 6540867515453498750 => {
16138 let responder = ::fidl_next::Responder::from_untyped(responder);
16139
16140 handler.close(responder).await;
16141 Ok(())
16142 }
16143
16144 2763219980499352582 => {
16145 let responder = ::fidl_next::Responder::from_untyped(responder);
16146
16147 handler.query(responder).await;
16148 Ok(())
16149 }
16150
16151 8689798978500614909 => {
16152 let responder = ::fidl_next::Responder::from_untyped(responder);
16153
16154 handler.deprecated_get_attr(responder).await;
16155 Ok(())
16156 }
16157
16158 4721673413776871238 => {
16159 let responder = ::fidl_next::Responder::from_untyped(responder);
16160
16161 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16162 Ok(decoded) => {
16163 handler
16164 .deprecated_set_attr(
16165 ::fidl_next::Request::from_decoded(decoded),
16166 responder,
16167 )
16168 .await;
16169 Ok(())
16170 }
16171 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16172 ordinal: 4721673413776871238,
16173 error,
16174 }),
16175 }
16176 }
16177
16178 6595803110182632097 => {
16179 let responder = ::fidl_next::Responder::from_untyped(responder);
16180
16181 handler.deprecated_get_flags(responder).await;
16182 Ok(())
16183 }
16184
16185 5950864159036794675 => {
16186 let responder = ::fidl_next::Responder::from_untyped(responder);
16187
16188 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16189 Ok(decoded) => {
16190 handler
16191 .deprecated_set_flags(
16192 ::fidl_next::Request::from_decoded(decoded),
16193 responder,
16194 )
16195 .await;
16196 Ok(())
16197 }
16198 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16199 ordinal: 5950864159036794675,
16200 error,
16201 }),
16202 }
16203 }
16204
16205 105530239381466147 => {
16206 let responder = ::fidl_next::Responder::from_untyped(responder);
16207
16208 handler.get_flags(responder).await;
16209 Ok(())
16210 }
16211
16212 6172186066099445416 => {
16213 let responder = ::fidl_next::Responder::from_untyped(responder);
16214
16215 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16216 Ok(decoded) => {
16217 handler
16218 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
16219 .await;
16220 Ok(())
16221 }
16222 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16223 ordinal: 6172186066099445416,
16224 error,
16225 }),
16226 }
16227 }
16228
16229 8013111122914313744 => {
16230 let responder = ::fidl_next::Responder::from_untyped(responder);
16231
16232 handler.query_filesystem(responder).await;
16233 Ok(())
16234 }
16235
16236 5788516050773961964 => {
16237 let responder = ::fidl_next::Responder::from_untyped(responder);
16238
16239 handler.get_token(responder).await;
16240 Ok(())
16241 }
16242
16243 4414537700416816443 => {
16244 let responder = ::fidl_next::Responder::from_untyped(responder);
16245
16246 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16247 Ok(decoded) => {
16248 handler
16249 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
16250 .await;
16251 Ok(())
16252 }
16253 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16254 ordinal: 4414537700416816443,
16255 error,
16256 }),
16257 }
16258 }
16259
16260 3677402239314018056 => {
16261 let responder = ::fidl_next::Responder::from_untyped(responder);
16262
16263 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16264 Ok(decoded) => {
16265 handler
16266 .update_attributes(
16267 ::fidl_next::Request::from_decoded(decoded),
16268 responder,
16269 )
16270 .await;
16271 Ok(())
16272 }
16273 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16274 ordinal: 3677402239314018056,
16275 error,
16276 }),
16277 }
16278 }
16279
16280 3196473584242777161 => {
16281 let responder = ::fidl_next::Responder::from_untyped(responder);
16282
16283 handler.sync(responder).await;
16284 Ok(())
16285 }
16286
16287 5043930208506967771 => {
16288 let responder = ::fidl_next::Responder::from_untyped(responder);
16289
16290 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16291 Ok(decoded) => {
16292 handler
16293 .get_extended_attribute(
16294 ::fidl_next::Request::from_decoded(decoded),
16295 responder,
16296 )
16297 .await;
16298 Ok(())
16299 }
16300 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16301 ordinal: 5043930208506967771,
16302 error,
16303 }),
16304 }
16305 }
16306
16307 5374223046099989052 => {
16308 let responder = ::fidl_next::Responder::from_untyped(responder);
16309
16310 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16311 Ok(decoded) => {
16312 handler
16313 .set_extended_attribute(
16314 ::fidl_next::Request::from_decoded(decoded),
16315 responder,
16316 )
16317 .await;
16318 Ok(())
16319 }
16320 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16321 ordinal: 5374223046099989052,
16322 error,
16323 }),
16324 }
16325 }
16326
16327 8794297771444732717 => {
16328 let responder = ::fidl_next::Responder::from_untyped(responder);
16329
16330 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16331 Ok(decoded) => {
16332 handler
16333 .remove_extended_attribute(
16334 ::fidl_next::Request::from_decoded(decoded),
16335 responder,
16336 )
16337 .await;
16338 Ok(())
16339 }
16340 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16341 ordinal: 8794297771444732717,
16342 error,
16343 }),
16344 }
16345 }
16346
16347 395825947633028830 => {
16348 let responder = ::fidl_next::Responder::from_untyped(responder);
16349
16350 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16351 Ok(decoded) => {
16352 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
16353 Ok(())
16354 }
16355 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16356 ordinal: 395825947633028830,
16357 error,
16358 }),
16359 }
16360 }
16361
16362 7651971425397809026 => {
16363 let responder = ::fidl_next::Responder::from_untyped(responder);
16364
16365 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16366 Ok(decoded) => {
16367 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
16368 Ok(())
16369 }
16370 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16371 ordinal: 7651971425397809026,
16372 error,
16373 }),
16374 }
16375 }
16376
16377 7545125870053689020 => {
16378 let responder = ::fidl_next::Responder::from_untyped(responder);
16379
16380 handler.describe(responder).await;
16381 Ok(())
16382 }
16383
16384 8649041485622956551 => {
16385 let responder = ::fidl_next::Responder::from_untyped(responder);
16386
16387 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16388 Ok(decoded) => {
16389 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
16390 Ok(())
16391 }
16392 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16393 ordinal: 8649041485622956551,
16394 error,
16395 }),
16396 }
16397 }
16398
16399 1587416148701180478 => {
16400 let responder = ::fidl_next::Responder::from_untyped(responder);
16401
16402 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16403 Ok(decoded) => {
16404 handler
16405 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
16406 .await;
16407 Ok(())
16408 }
16409 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16410 ordinal: 1587416148701180478,
16411 error,
16412 }),
16413 }
16414 }
16415
16416 8736683935131400491 => {
16417 let responder = ::fidl_next::Responder::from_untyped(responder);
16418
16419 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16420 Ok(decoded) => {
16421 handler
16422 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
16423 .await;
16424 Ok(())
16425 }
16426 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16427 ordinal: 8736683935131400491,
16428 error,
16429 }),
16430 }
16431 }
16432
16433 3134648685270758458 => {
16434 let responder = ::fidl_next::Responder::from_untyped(responder);
16435
16436 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16437 Ok(decoded) => {
16438 handler
16439 .resize(::fidl_next::Request::from_decoded(decoded), responder)
16440 .await;
16441 Ok(())
16442 }
16443 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16444 ordinal: 3134648685270758458,
16445 error,
16446 }),
16447 }
16448 }
16449
16450 46911652864194091 => {
16451 let responder = ::fidl_next::Responder::from_untyped(responder);
16452
16453 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16454 Ok(decoded) => {
16455 handler
16456 .get_backing_memory(
16457 ::fidl_next::Request::from_decoded(decoded),
16458 responder,
16459 )
16460 .await;
16461 Ok(())
16462 }
16463 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16464 ordinal: 46911652864194091,
16465 error,
16466 }),
16467 }
16468 }
16469
16470 8645235848064269614 => {
16471 let responder = ::fidl_next::Responder::from_untyped(responder);
16472
16473 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16474 Ok(decoded) => {
16475 handler
16476 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
16477 .await;
16478 Ok(())
16479 }
16480 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16481 ordinal: 8645235848064269614,
16482 error,
16483 }),
16484 }
16485 }
16486
16487 3189145313204943035 => {
16488 let responder = ::fidl_next::Responder::from_untyped(responder);
16489
16490 match ::fidl_next::AsDecoderExt::into_decoded(message) {
16491 Ok(decoded) => {
16492 handler
16493 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
16494 .await;
16495 Ok(())
16496 }
16497 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16498 ordinal: 3189145313204943035,
16499 error,
16500 }),
16501 }
16502 }
16503
16504 ordinal => {
16505 handler.on_unknown_interaction(ordinal).await;
16506 if ::core::matches!(
16507 message.header().flexibility(),
16508 ::fidl_next::protocol::Flexibility::Strict
16509 ) {
16510 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16511 } else {
16512 responder
16513 .respond_framework_error(
16514 ordinal,
16515 ::fidl_next::FrameworkError::UnknownMethod,
16516 )
16517 .expect("encoding a framework error should never fail")
16518 .await?;
16519 Ok(())
16520 }
16521 }
16522 }
16523 }
16524}
16525
16526pub trait FileClientHandler<
16530 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16531 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16532>
16533{
16534 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
16535 fn on_open(
16536 &mut self,
16537
16538 request: ::fidl_next::Request<file::OnOpen, ___T>,
16539 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16540
16541 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
16542 fn on_representation(
16543 &mut self,
16544
16545 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
16546 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16547
16548 fn on_unknown_interaction(
16549 &mut self,
16550 ordinal: u64,
16551 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16552 ::core::future::ready(())
16553 }
16554}
16555
16556impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for File
16557where
16558 ___H: FileClientHandler<___T> + ::core::marker::Send,
16559 ___T: ::fidl_next::Transport,
16560 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
16561 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16562 Constraint = (),
16563 >,
16564 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
16565 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16566 Constraint = (),
16567 >,
16568{
16569 async fn on_event(
16570 handler: &mut ___H,
16571 mut message: ::fidl_next::Message<___T>,
16572 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
16573 match *message.header().ordinal {
16574 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16575 Ok(decoded) => {
16576 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
16577 Ok(())
16578 }
16579 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16580 ordinal: 9207534335756671346,
16581 error,
16582 }),
16583 },
16584
16585 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16586 Ok(decoded) => {
16587 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
16588 Ok(())
16589 }
16590 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16591 ordinal: 6679970090861613324,
16592 error,
16593 }),
16594 },
16595
16596 ordinal => {
16597 handler.on_unknown_interaction(ordinal).await;
16598 if ::core::matches!(
16599 message.header().flexibility(),
16600 ::fidl_next::protocol::Flexibility::Strict
16601 ) {
16602 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
16603 } else {
16604 Ok(())
16605 }
16606 }
16607 }
16608 }
16609}
16610
16611pub trait FileServerHandler<
16615 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
16616 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
16617>
16618{
16619 #[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"]
16620 fn advisory_lock(
16621 &mut self,
16622
16623 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
16624
16625 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
16626 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16627
16628 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
16629 fn link_into(
16630 &mut self,
16631
16632 request: ::fidl_next::Request<file::LinkInto, ___T>,
16633
16634 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
16635 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16636
16637 fn clone(
16638 &mut self,
16639
16640 request: ::fidl_next::Request<file::Clone, ___T>,
16641 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16642
16643 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
16644 fn close(
16645 &mut self,
16646
16647 responder: ::fidl_next::Responder<file::Close, ___T>,
16648 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16649
16650 fn query(
16651 &mut self,
16652
16653 responder: ::fidl_next::Responder<file::Query, ___T>,
16654 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16655
16656 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
16657 fn deprecated_get_attr(
16658 &mut self,
16659
16660 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
16661 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16662
16663 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
16664 fn deprecated_set_attr(
16665 &mut self,
16666
16667 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
16668
16669 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
16670 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16671
16672 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
16673 fn deprecated_get_flags(
16674 &mut self,
16675
16676 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
16677 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16678
16679 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
16680 fn deprecated_set_flags(
16681 &mut self,
16682
16683 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
16684
16685 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
16686 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16687
16688 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
16689 fn get_flags(
16690 &mut self,
16691
16692 responder: ::fidl_next::Responder<file::GetFlags, ___T>,
16693 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16694
16695 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
16696 fn set_flags(
16697 &mut self,
16698
16699 request: ::fidl_next::Request<file::SetFlags, ___T>,
16700
16701 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
16702 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16703
16704 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
16705 fn query_filesystem(
16706 &mut self,
16707
16708 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
16709 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16710
16711 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
16712 fn get_token(
16713 &mut self,
16714
16715 responder: ::fidl_next::Responder<file::GetToken, ___T>,
16716 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16717
16718 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
16719 fn get_attributes(
16720 &mut self,
16721
16722 request: ::fidl_next::Request<file::GetAttributes, ___T>,
16723
16724 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
16725 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16726
16727 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
16728 fn update_attributes(
16729 &mut self,
16730
16731 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
16732
16733 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
16734 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16735
16736 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
16737 fn sync(
16738 &mut self,
16739
16740 responder: ::fidl_next::Responder<file::Sync, ___T>,
16741 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16742
16743 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
16744 fn list_extended_attributes(
16745 &mut self,
16746
16747 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
16748 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16749
16750 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
16751 fn get_extended_attribute(
16752 &mut self,
16753
16754 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
16755
16756 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
16757 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16758
16759 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
16760 fn set_extended_attribute(
16761 &mut self,
16762
16763 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
16764
16765 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
16766 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16767
16768 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
16769 fn remove_extended_attribute(
16770 &mut self,
16771
16772 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
16773
16774 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
16775 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16776
16777 #[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"]
16778 fn read(
16779 &mut self,
16780
16781 request: ::fidl_next::Request<file::Read, ___T>,
16782
16783 responder: ::fidl_next::Responder<file::Read, ___T>,
16784 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16785
16786 #[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"]
16787 fn write(
16788 &mut self,
16789
16790 request: ::fidl_next::Request<file::Write, ___T>,
16791
16792 responder: ::fidl_next::Responder<file::Write, ___T>,
16793 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16794
16795 fn describe(
16796 &mut self,
16797
16798 responder: ::fidl_next::Responder<file::Describe, ___T>,
16799 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16800
16801 #[doc = " Moves the offset at which the next invocation of [`Read`] or [`Write`]\n will occur. The seek offset is specific to each file connection.\n\n + request `origin` the reference point where `offset` will be based on.\n + request `offset` the number of bytes to seek.\n - response `offset_from_start` the adjusted seek offset, from the start\n of the file.\n\n This method does not require any rights.\n"]
16802 fn seek(
16803 &mut self,
16804
16805 request: ::fidl_next::Request<file::Seek, ___T>,
16806
16807 responder: ::fidl_next::Responder<file::Seek, ___T>,
16808 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16809
16810 #[doc = " Reads up to \'count\' bytes at the provided offset.\n Does not affect the seek offset.\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 `ReadAt` has hit\n the end of file as part of this operation.\n * If `data.length` is zero while `count` is not, it means that `offset`\n is at or past the end of file, and no data can be read.\n * If `count` is zero, the server should perform all the checks ensuring\n read access without actually reading 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"]
16811 fn read_at(
16812 &mut self,
16813
16814 request: ::fidl_next::Request<file::ReadAt, ___T>,
16815
16816 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
16817 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16818
16819 #[doc = " Writes data at the provided offset.\n Does not affect the seek offset.\n\n The file size may grow if `offset` plus `data.length` is past the\n current end of file.\n\n + request `data` the byte buffer to write to the file.\n + request `offset` the offset from start of the file to begin writing.\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 will return a\n successful write of zero bytes.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
16820 fn write_at(
16821 &mut self,
16822
16823 request: ::fidl_next::Request<file::WriteAt, ___T>,
16824
16825 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
16826 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16827
16828 #[doc = " Shrinks or grows the file size to \'length\' bytes.\n\n If file size is reduced by this operation, the extra trailing data\'\n is discarded.\n If file size is increased by this operation, the extended area appears\n as if it was zeroed.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
16829 fn resize(
16830 &mut self,
16831
16832 request: ::fidl_next::Request<file::Resize, ___T>,
16833
16834 responder: ::fidl_next::Responder<file::Resize, ___T>,
16835 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16836
16837 #[doc = " Acquires a [`zx.Handle:VMO`] representing this file, if there is one,\n with the requested access rights.\n\n Implementations are not required to implement files backed by VMOs so\n this request may fail. Additionally, implementations may only support\n a certain subset of the flags. Clients should be prepared with fallback\n behavior if this request fails.\n\n If a client specifies neither `PRIVATE_CLONE` nor `SHARED_BUFFER`, the\n implementation is free to choose the semantics of the returned VMO.\n\n + request `flags` a [`VmoFlags`] indicating the desired mode of access.\n - response `vmo` the requested [`zx.Handle:VMO`].\n * error a [`zx.Status`] value indicating the failure.\n\n This method requires the following rights:\n\n * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].\n * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].\n * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].\n"]
16838 fn get_backing_memory(
16839 &mut self,
16840
16841 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
16842
16843 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
16844 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16845
16846 #[doc = " Pre-allocate on-disk space for this file.\n"]
16847 fn allocate(
16848 &mut self,
16849
16850 request: ::fidl_next::Request<file::Allocate, ___T>,
16851
16852 responder: ::fidl_next::Responder<file::Allocate, ___T>,
16853 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16854
16855 #[doc = " Enables verification for the file (permanently) which involves computing a merkle tree for\n the file. Forces a flush prior to building the merkle tree to ensure cached data is\n captured. Future reads will be verified against the computed merkle tree and writes will be\n rejected. This method can take some time to complete as it depends on the size of the file.\n This method can be aborted by closing the connection that this method was issued on.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n Returns `ZX_ERR_NOT_SUPPORTED` if the filesystem does not support verity.\n Returns `ZX_ERR_ALREADY_EXISTS` if the file was already fsverity-enabled.\n Also returns any error that might arise from reading the file, or from flushing the file,\n such as `ZX_ERR_IO`.\n"]
16856 fn enable_verity(
16857 &mut self,
16858
16859 request: ::fidl_next::Request<file::EnableVerity, ___T>,
16860
16861 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
16862 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
16863
16864 fn on_unknown_interaction(
16865 &mut self,
16866 ordinal: u64,
16867 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
16868 ::core::future::ready(())
16869 }
16870}
16871
16872impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for File
16873where
16874 ___H: FileServerHandler<___T> + ::core::marker::Send,
16875 ___T: ::fidl_next::Transport,
16876 for<'de> crate::wire::AdvisoryLockingAdvisoryLockRequest<'de>: ::fidl_next::Decode<
16877 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16878 Constraint = (),
16879 >,
16880 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
16881 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16882 Constraint = (),
16883 >,
16884 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
16885 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16886 Constraint = (),
16887 >,
16888 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
16889 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16890 Constraint = (),
16891 >,
16892 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
16893 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16894 Constraint = (),
16895 >,
16896 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
16897 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16898 Constraint = (),
16899 >,
16900 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
16901 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16902 Constraint = (),
16903 >,
16904 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
16905 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16906 Constraint = (),
16907 >,
16908 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
16909 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16910 Constraint = (),
16911 >,
16912 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16913 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16914 Constraint = (),
16915 >,
16916 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16917 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16918 Constraint = (),
16919 >,
16920 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
16921 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16922 Constraint = (),
16923 >,
16924 for<'de> crate::wire::ReadableReadRequest: ::fidl_next::Decode<
16925 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16926 Constraint = (),
16927 >,
16928 for<'de> crate::wire::WritableWriteRequest<'de>: ::fidl_next::Decode<
16929 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16930 Constraint = (),
16931 >,
16932 for<'de> crate::wire::FileSeekRequest: ::fidl_next::Decode<
16933 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16934 Constraint = (),
16935 >,
16936 for<'de> crate::wire::FileReadAtRequest: ::fidl_next::Decode<
16937 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16938 Constraint = (),
16939 >,
16940 for<'de> crate::wire::FileWriteAtRequest<'de>: ::fidl_next::Decode<
16941 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16942 Constraint = (),
16943 >,
16944 for<'de> crate::wire::FileResizeRequest: ::fidl_next::Decode<
16945 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16946 Constraint = (),
16947 >,
16948 for<'de> crate::wire::FileGetBackingMemoryRequest: ::fidl_next::Decode<
16949 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16950 Constraint = (),
16951 >,
16952 for<'de> crate::wire::FileAllocateRequest: ::fidl_next::Decode<
16953 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16954 Constraint = (),
16955 >,
16956 for<'de> crate::wire::FileEnableVerityRequest<'de>: ::fidl_next::Decode<
16957 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
16958 Constraint = (),
16959 >,
16960{
16961 async fn on_one_way(
16962 handler: &mut ___H,
16963 mut message: ::fidl_next::Message<___T>,
16964 ) -> ::core::result::Result<
16965 (),
16966 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
16967 > {
16968 match *message.header().ordinal {
16969 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16970 Ok(decoded) => {
16971 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
16972 Ok(())
16973 }
16974 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16975 ordinal: 2366825959783828089,
16976 error,
16977 }),
16978 },
16979
16980 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
16981 Ok(decoded) => {
16982 handler
16983 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
16984 .await;
16985 Ok(())
16986 }
16987 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
16988 ordinal: 5431626189872037072,
16989 error,
16990 }),
16991 },
16992
16993 ordinal => {
16994 handler.on_unknown_interaction(ordinal).await;
16995 if ::core::matches!(
16996 message.header().flexibility(),
16997 ::fidl_next::protocol::Flexibility::Strict
16998 ) {
16999 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17000 } else {
17001 Ok(())
17002 }
17003 }
17004 }
17005 }
17006
17007 async fn on_two_way(
17008 handler: &mut ___H,
17009 mut message: ::fidl_next::Message<___T>,
17010 responder: ::fidl_next::protocol::Responder<___T>,
17011 ) -> ::core::result::Result<
17012 (),
17013 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
17014 > {
17015 match *message.header().ordinal {
17016 7992130864415541162 => {
17017 let responder = ::fidl_next::Responder::from_untyped(responder);
17018
17019 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17020 Ok(decoded) => {
17021 handler
17022 .advisory_lock(::fidl_next::Request::from_decoded(decoded), responder)
17023 .await;
17024 Ok(())
17025 }
17026 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17027 ordinal: 7992130864415541162,
17028 error,
17029 }),
17030 }
17031 }
17032
17033 6121399674497678964 => {
17034 let responder = ::fidl_next::Responder::from_untyped(responder);
17035
17036 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17037 Ok(decoded) => {
17038 handler
17039 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
17040 .await;
17041 Ok(())
17042 }
17043 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17044 ordinal: 6121399674497678964,
17045 error,
17046 }),
17047 }
17048 }
17049
17050 6540867515453498750 => {
17051 let responder = ::fidl_next::Responder::from_untyped(responder);
17052
17053 handler.close(responder).await;
17054 Ok(())
17055 }
17056
17057 2763219980499352582 => {
17058 let responder = ::fidl_next::Responder::from_untyped(responder);
17059
17060 handler.query(responder).await;
17061 Ok(())
17062 }
17063
17064 8689798978500614909 => {
17065 let responder = ::fidl_next::Responder::from_untyped(responder);
17066
17067 handler.deprecated_get_attr(responder).await;
17068 Ok(())
17069 }
17070
17071 4721673413776871238 => {
17072 let responder = ::fidl_next::Responder::from_untyped(responder);
17073
17074 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17075 Ok(decoded) => {
17076 handler
17077 .deprecated_set_attr(
17078 ::fidl_next::Request::from_decoded(decoded),
17079 responder,
17080 )
17081 .await;
17082 Ok(())
17083 }
17084 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17085 ordinal: 4721673413776871238,
17086 error,
17087 }),
17088 }
17089 }
17090
17091 6595803110182632097 => {
17092 let responder = ::fidl_next::Responder::from_untyped(responder);
17093
17094 handler.deprecated_get_flags(responder).await;
17095 Ok(())
17096 }
17097
17098 5950864159036794675 => {
17099 let responder = ::fidl_next::Responder::from_untyped(responder);
17100
17101 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17102 Ok(decoded) => {
17103 handler
17104 .deprecated_set_flags(
17105 ::fidl_next::Request::from_decoded(decoded),
17106 responder,
17107 )
17108 .await;
17109 Ok(())
17110 }
17111 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17112 ordinal: 5950864159036794675,
17113 error,
17114 }),
17115 }
17116 }
17117
17118 105530239381466147 => {
17119 let responder = ::fidl_next::Responder::from_untyped(responder);
17120
17121 handler.get_flags(responder).await;
17122 Ok(())
17123 }
17124
17125 6172186066099445416 => {
17126 let responder = ::fidl_next::Responder::from_untyped(responder);
17127
17128 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17129 Ok(decoded) => {
17130 handler
17131 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
17132 .await;
17133 Ok(())
17134 }
17135 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17136 ordinal: 6172186066099445416,
17137 error,
17138 }),
17139 }
17140 }
17141
17142 8013111122914313744 => {
17143 let responder = ::fidl_next::Responder::from_untyped(responder);
17144
17145 handler.query_filesystem(responder).await;
17146 Ok(())
17147 }
17148
17149 5788516050773961964 => {
17150 let responder = ::fidl_next::Responder::from_untyped(responder);
17151
17152 handler.get_token(responder).await;
17153 Ok(())
17154 }
17155
17156 4414537700416816443 => {
17157 let responder = ::fidl_next::Responder::from_untyped(responder);
17158
17159 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17160 Ok(decoded) => {
17161 handler
17162 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
17163 .await;
17164 Ok(())
17165 }
17166 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17167 ordinal: 4414537700416816443,
17168 error,
17169 }),
17170 }
17171 }
17172
17173 3677402239314018056 => {
17174 let responder = ::fidl_next::Responder::from_untyped(responder);
17175
17176 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17177 Ok(decoded) => {
17178 handler
17179 .update_attributes(
17180 ::fidl_next::Request::from_decoded(decoded),
17181 responder,
17182 )
17183 .await;
17184 Ok(())
17185 }
17186 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17187 ordinal: 3677402239314018056,
17188 error,
17189 }),
17190 }
17191 }
17192
17193 3196473584242777161 => {
17194 let responder = ::fidl_next::Responder::from_untyped(responder);
17195
17196 handler.sync(responder).await;
17197 Ok(())
17198 }
17199
17200 5043930208506967771 => {
17201 let responder = ::fidl_next::Responder::from_untyped(responder);
17202
17203 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17204 Ok(decoded) => {
17205 handler
17206 .get_extended_attribute(
17207 ::fidl_next::Request::from_decoded(decoded),
17208 responder,
17209 )
17210 .await;
17211 Ok(())
17212 }
17213 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17214 ordinal: 5043930208506967771,
17215 error,
17216 }),
17217 }
17218 }
17219
17220 5374223046099989052 => {
17221 let responder = ::fidl_next::Responder::from_untyped(responder);
17222
17223 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17224 Ok(decoded) => {
17225 handler
17226 .set_extended_attribute(
17227 ::fidl_next::Request::from_decoded(decoded),
17228 responder,
17229 )
17230 .await;
17231 Ok(())
17232 }
17233 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17234 ordinal: 5374223046099989052,
17235 error,
17236 }),
17237 }
17238 }
17239
17240 8794297771444732717 => {
17241 let responder = ::fidl_next::Responder::from_untyped(responder);
17242
17243 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17244 Ok(decoded) => {
17245 handler
17246 .remove_extended_attribute(
17247 ::fidl_next::Request::from_decoded(decoded),
17248 responder,
17249 )
17250 .await;
17251 Ok(())
17252 }
17253 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17254 ordinal: 8794297771444732717,
17255 error,
17256 }),
17257 }
17258 }
17259
17260 395825947633028830 => {
17261 let responder = ::fidl_next::Responder::from_untyped(responder);
17262
17263 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17264 Ok(decoded) => {
17265 handler.read(::fidl_next::Request::from_decoded(decoded), responder).await;
17266 Ok(())
17267 }
17268 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17269 ordinal: 395825947633028830,
17270 error,
17271 }),
17272 }
17273 }
17274
17275 7651971425397809026 => {
17276 let responder = ::fidl_next::Responder::from_untyped(responder);
17277
17278 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17279 Ok(decoded) => {
17280 handler.write(::fidl_next::Request::from_decoded(decoded), responder).await;
17281 Ok(())
17282 }
17283 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17284 ordinal: 7651971425397809026,
17285 error,
17286 }),
17287 }
17288 }
17289
17290 7545125870053689020 => {
17291 let responder = ::fidl_next::Responder::from_untyped(responder);
17292
17293 handler.describe(responder).await;
17294 Ok(())
17295 }
17296
17297 8649041485622956551 => {
17298 let responder = ::fidl_next::Responder::from_untyped(responder);
17299
17300 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17301 Ok(decoded) => {
17302 handler.seek(::fidl_next::Request::from_decoded(decoded), responder).await;
17303 Ok(())
17304 }
17305 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17306 ordinal: 8649041485622956551,
17307 error,
17308 }),
17309 }
17310 }
17311
17312 1587416148701180478 => {
17313 let responder = ::fidl_next::Responder::from_untyped(responder);
17314
17315 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17316 Ok(decoded) => {
17317 handler
17318 .read_at(::fidl_next::Request::from_decoded(decoded), responder)
17319 .await;
17320 Ok(())
17321 }
17322 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17323 ordinal: 1587416148701180478,
17324 error,
17325 }),
17326 }
17327 }
17328
17329 8736683935131400491 => {
17330 let responder = ::fidl_next::Responder::from_untyped(responder);
17331
17332 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17333 Ok(decoded) => {
17334 handler
17335 .write_at(::fidl_next::Request::from_decoded(decoded), responder)
17336 .await;
17337 Ok(())
17338 }
17339 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17340 ordinal: 8736683935131400491,
17341 error,
17342 }),
17343 }
17344 }
17345
17346 3134648685270758458 => {
17347 let responder = ::fidl_next::Responder::from_untyped(responder);
17348
17349 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17350 Ok(decoded) => {
17351 handler
17352 .resize(::fidl_next::Request::from_decoded(decoded), responder)
17353 .await;
17354 Ok(())
17355 }
17356 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17357 ordinal: 3134648685270758458,
17358 error,
17359 }),
17360 }
17361 }
17362
17363 46911652864194091 => {
17364 let responder = ::fidl_next::Responder::from_untyped(responder);
17365
17366 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17367 Ok(decoded) => {
17368 handler
17369 .get_backing_memory(
17370 ::fidl_next::Request::from_decoded(decoded),
17371 responder,
17372 )
17373 .await;
17374 Ok(())
17375 }
17376 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17377 ordinal: 46911652864194091,
17378 error,
17379 }),
17380 }
17381 }
17382
17383 8645235848064269614 => {
17384 let responder = ::fidl_next::Responder::from_untyped(responder);
17385
17386 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17387 Ok(decoded) => {
17388 handler
17389 .allocate(::fidl_next::Request::from_decoded(decoded), responder)
17390 .await;
17391 Ok(())
17392 }
17393 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17394 ordinal: 8645235848064269614,
17395 error,
17396 }),
17397 }
17398 }
17399
17400 3189145313204943035 => {
17401 let responder = ::fidl_next::Responder::from_untyped(responder);
17402
17403 match ::fidl_next::AsDecoderExt::into_decoded(message) {
17404 Ok(decoded) => {
17405 handler
17406 .enable_verity(::fidl_next::Request::from_decoded(decoded), responder)
17407 .await;
17408 Ok(())
17409 }
17410 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
17411 ordinal: 3189145313204943035,
17412 error,
17413 }),
17414 }
17415 }
17416
17417 ordinal => {
17418 handler.on_unknown_interaction(ordinal).await;
17419 if ::core::matches!(
17420 message.header().flexibility(),
17421 ::fidl_next::protocol::Flexibility::Strict
17422 ) {
17423 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
17424 } else {
17425 responder
17426 .respond_framework_error(
17427 ordinal,
17428 ::fidl_next::FrameworkError::UnknownMethod,
17429 )
17430 .expect("encoding a framework error should never fail")
17431 .await?;
17432 Ok(())
17433 }
17434 }
17435 }
17436 }
17437}
17438
17439impl<___T> FileClientHandler<___T> for ::fidl_next::IgnoreEvents
17440where
17441 ___T: ::fidl_next::Transport,
17442{
17443 async fn on_open(&mut self, _: ::fidl_next::Request<file::OnOpen, ___T>) {}
17444
17445 async fn on_representation(&mut self, _: ::fidl_next::Request<file::OnRepresentation, ___T>) {}
17446
17447 async fn on_unknown_interaction(&mut self, _: u64) {}
17448}
17449
17450impl<___H, ___T> FileLocalClientHandler<___T> for ::fidl_next::Local<___H>
17451where
17452 ___H: FileClientHandler<___T>,
17453 ___T: ::fidl_next::Transport,
17454{
17455 async fn on_open(&mut self, request: ::fidl_next::Request<file::OnOpen, ___T>) {
17456 ___H::on_open(&mut self.0, request).await
17457 }
17458
17459 async fn on_representation(
17460 &mut self,
17461
17462 request: ::fidl_next::Request<file::OnRepresentation, ___T>,
17463 ) {
17464 ___H::on_representation(&mut self.0, request).await
17465 }
17466
17467 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17468 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17469 }
17470}
17471
17472impl<___H, ___T> FileLocalServerHandler<___T> for ::fidl_next::Local<___H>
17473where
17474 ___H: FileServerHandler<___T>,
17475 ___T: ::fidl_next::Transport,
17476{
17477 async fn advisory_lock(
17478 &mut self,
17479
17480 request: ::fidl_next::Request<file::AdvisoryLock, ___T>,
17481
17482 responder: ::fidl_next::Responder<file::AdvisoryLock, ___T>,
17483 ) {
17484 ___H::advisory_lock(&mut self.0, request, responder).await
17485 }
17486
17487 async fn link_into(
17488 &mut self,
17489
17490 request: ::fidl_next::Request<file::LinkInto, ___T>,
17491
17492 responder: ::fidl_next::Responder<file::LinkInto, ___T>,
17493 ) {
17494 ___H::link_into(&mut self.0, request, responder).await
17495 }
17496
17497 async fn clone(&mut self, request: ::fidl_next::Request<file::Clone, ___T>) {
17498 ___H::clone(&mut self.0, request).await
17499 }
17500
17501 async fn close(&mut self, responder: ::fidl_next::Responder<file::Close, ___T>) {
17502 ___H::close(&mut self.0, responder).await
17503 }
17504
17505 async fn query(&mut self, responder: ::fidl_next::Responder<file::Query, ___T>) {
17506 ___H::query(&mut self.0, responder).await
17507 }
17508
17509 async fn deprecated_get_attr(
17510 &mut self,
17511
17512 responder: ::fidl_next::Responder<file::DeprecatedGetAttr, ___T>,
17513 ) {
17514 ___H::deprecated_get_attr(&mut self.0, responder).await
17515 }
17516
17517 async fn deprecated_set_attr(
17518 &mut self,
17519
17520 request: ::fidl_next::Request<file::DeprecatedSetAttr, ___T>,
17521
17522 responder: ::fidl_next::Responder<file::DeprecatedSetAttr, ___T>,
17523 ) {
17524 ___H::deprecated_set_attr(&mut self.0, request, responder).await
17525 }
17526
17527 async fn deprecated_get_flags(
17528 &mut self,
17529
17530 responder: ::fidl_next::Responder<file::DeprecatedGetFlags, ___T>,
17531 ) {
17532 ___H::deprecated_get_flags(&mut self.0, responder).await
17533 }
17534
17535 async fn deprecated_set_flags(
17536 &mut self,
17537
17538 request: ::fidl_next::Request<file::DeprecatedSetFlags, ___T>,
17539
17540 responder: ::fidl_next::Responder<file::DeprecatedSetFlags, ___T>,
17541 ) {
17542 ___H::deprecated_set_flags(&mut self.0, request, responder).await
17543 }
17544
17545 async fn get_flags(&mut self, responder: ::fidl_next::Responder<file::GetFlags, ___T>) {
17546 ___H::get_flags(&mut self.0, responder).await
17547 }
17548
17549 async fn set_flags(
17550 &mut self,
17551
17552 request: ::fidl_next::Request<file::SetFlags, ___T>,
17553
17554 responder: ::fidl_next::Responder<file::SetFlags, ___T>,
17555 ) {
17556 ___H::set_flags(&mut self.0, request, responder).await
17557 }
17558
17559 async fn query_filesystem(
17560 &mut self,
17561
17562 responder: ::fidl_next::Responder<file::QueryFilesystem, ___T>,
17563 ) {
17564 ___H::query_filesystem(&mut self.0, responder).await
17565 }
17566
17567 async fn get_token(&mut self, responder: ::fidl_next::Responder<file::GetToken, ___T>) {
17568 ___H::get_token(&mut self.0, responder).await
17569 }
17570
17571 async fn get_attributes(
17572 &mut self,
17573
17574 request: ::fidl_next::Request<file::GetAttributes, ___T>,
17575
17576 responder: ::fidl_next::Responder<file::GetAttributes, ___T>,
17577 ) {
17578 ___H::get_attributes(&mut self.0, request, responder).await
17579 }
17580
17581 async fn update_attributes(
17582 &mut self,
17583
17584 request: ::fidl_next::Request<file::UpdateAttributes, ___T>,
17585
17586 responder: ::fidl_next::Responder<file::UpdateAttributes, ___T>,
17587 ) {
17588 ___H::update_attributes(&mut self.0, request, responder).await
17589 }
17590
17591 async fn sync(&mut self, responder: ::fidl_next::Responder<file::Sync, ___T>) {
17592 ___H::sync(&mut self.0, responder).await
17593 }
17594
17595 async fn list_extended_attributes(
17596 &mut self,
17597
17598 request: ::fidl_next::Request<file::ListExtendedAttributes, ___T>,
17599 ) {
17600 ___H::list_extended_attributes(&mut self.0, request).await
17601 }
17602
17603 async fn get_extended_attribute(
17604 &mut self,
17605
17606 request: ::fidl_next::Request<file::GetExtendedAttribute, ___T>,
17607
17608 responder: ::fidl_next::Responder<file::GetExtendedAttribute, ___T>,
17609 ) {
17610 ___H::get_extended_attribute(&mut self.0, request, responder).await
17611 }
17612
17613 async fn set_extended_attribute(
17614 &mut self,
17615
17616 request: ::fidl_next::Request<file::SetExtendedAttribute, ___T>,
17617
17618 responder: ::fidl_next::Responder<file::SetExtendedAttribute, ___T>,
17619 ) {
17620 ___H::set_extended_attribute(&mut self.0, request, responder).await
17621 }
17622
17623 async fn remove_extended_attribute(
17624 &mut self,
17625
17626 request: ::fidl_next::Request<file::RemoveExtendedAttribute, ___T>,
17627
17628 responder: ::fidl_next::Responder<file::RemoveExtendedAttribute, ___T>,
17629 ) {
17630 ___H::remove_extended_attribute(&mut self.0, request, responder).await
17631 }
17632
17633 async fn read(
17634 &mut self,
17635
17636 request: ::fidl_next::Request<file::Read, ___T>,
17637
17638 responder: ::fidl_next::Responder<file::Read, ___T>,
17639 ) {
17640 ___H::read(&mut self.0, request, responder).await
17641 }
17642
17643 async fn write(
17644 &mut self,
17645
17646 request: ::fidl_next::Request<file::Write, ___T>,
17647
17648 responder: ::fidl_next::Responder<file::Write, ___T>,
17649 ) {
17650 ___H::write(&mut self.0, request, responder).await
17651 }
17652
17653 async fn describe(&mut self, responder: ::fidl_next::Responder<file::Describe, ___T>) {
17654 ___H::describe(&mut self.0, responder).await
17655 }
17656
17657 async fn seek(
17658 &mut self,
17659
17660 request: ::fidl_next::Request<file::Seek, ___T>,
17661
17662 responder: ::fidl_next::Responder<file::Seek, ___T>,
17663 ) {
17664 ___H::seek(&mut self.0, request, responder).await
17665 }
17666
17667 async fn read_at(
17668 &mut self,
17669
17670 request: ::fidl_next::Request<file::ReadAt, ___T>,
17671
17672 responder: ::fidl_next::Responder<file::ReadAt, ___T>,
17673 ) {
17674 ___H::read_at(&mut self.0, request, responder).await
17675 }
17676
17677 async fn write_at(
17678 &mut self,
17679
17680 request: ::fidl_next::Request<file::WriteAt, ___T>,
17681
17682 responder: ::fidl_next::Responder<file::WriteAt, ___T>,
17683 ) {
17684 ___H::write_at(&mut self.0, request, responder).await
17685 }
17686
17687 async fn resize(
17688 &mut self,
17689
17690 request: ::fidl_next::Request<file::Resize, ___T>,
17691
17692 responder: ::fidl_next::Responder<file::Resize, ___T>,
17693 ) {
17694 ___H::resize(&mut self.0, request, responder).await
17695 }
17696
17697 async fn get_backing_memory(
17698 &mut self,
17699
17700 request: ::fidl_next::Request<file::GetBackingMemory, ___T>,
17701
17702 responder: ::fidl_next::Responder<file::GetBackingMemory, ___T>,
17703 ) {
17704 ___H::get_backing_memory(&mut self.0, request, responder).await
17705 }
17706
17707 async fn allocate(
17708 &mut self,
17709
17710 request: ::fidl_next::Request<file::Allocate, ___T>,
17711
17712 responder: ::fidl_next::Responder<file::Allocate, ___T>,
17713 ) {
17714 ___H::allocate(&mut self.0, request, responder).await
17715 }
17716
17717 async fn enable_verity(
17718 &mut self,
17719
17720 request: ::fidl_next::Request<file::EnableVerity, ___T>,
17721
17722 responder: ::fidl_next::Responder<file::EnableVerity, ___T>,
17723 ) {
17724 ___H::enable_verity(&mut self.0, request, responder).await
17725 }
17726
17727 async fn on_unknown_interaction(&mut self, ordinal: u64) {
17728 ___H::on_unknown_interaction(&mut self.0, ordinal).await
17729 }
17730}
17731
17732#[doc = " A [\'Node\'] which contains a symbolic link.\n"]
17734#[derive(PartialEq, Debug)]
17735pub struct Symlink;
17736
17737impl ::fidl_next::Discoverable for Symlink {
17738 const PROTOCOL_NAME: &'static str = "fuchsia.io.Symlink";
17739}
17740
17741#[cfg(target_os = "fuchsia")]
17742impl ::fidl_next::HasTransport for Symlink {
17743 type Transport = ::fidl_next::fuchsia::zx::Channel;
17744}
17745
17746pub mod symlink {
17747 pub mod prelude {
17748 pub use crate::{
17749 Symlink, SymlinkClientHandler, SymlinkLocalClientHandler, SymlinkLocalServerHandler,
17750 SymlinkServerHandler, symlink,
17751 };
17752
17753 pub use crate::natural::ExtendedAttributeValue;
17754
17755 pub use crate::natural::LinkableLinkIntoRequest;
17756
17757 pub use crate::natural::LinkableLinkIntoResponse;
17758
17759 pub use crate::natural::MutableNodeAttributes;
17760
17761 pub use crate::natural::NodeAttributes2;
17762
17763 pub use crate::natural::NodeDeprecatedGetAttrResponse;
17764
17765 pub use crate::natural::NodeDeprecatedGetFlagsResponse;
17766
17767 pub use crate::natural::NodeDeprecatedSetAttrRequest;
17768
17769 pub use crate::natural::NodeDeprecatedSetAttrResponse;
17770
17771 pub use crate::natural::NodeDeprecatedSetFlagsRequest;
17772
17773 pub use crate::natural::NodeDeprecatedSetFlagsResponse;
17774
17775 pub use crate::natural::NodeGetAttributesRequest;
17776
17777 pub use crate::natural::NodeGetExtendedAttributeRequest;
17778
17779 pub use crate::natural::NodeListExtendedAttributesRequest;
17780
17781 pub use crate::natural::NodeOnOpenRequest;
17782
17783 pub use crate::natural::NodeQueryFilesystemResponse;
17784
17785 pub use crate::natural::NodeRemoveExtendedAttributeRequest;
17786
17787 pub use crate::natural::NodeSetExtendedAttributeRequest;
17788
17789 pub use crate::natural::NodeSetFlagsRequest;
17790
17791 pub use crate::natural::NodeGetFlagsResponse;
17792
17793 pub use crate::natural::NodeGetTokenResponse;
17794
17795 pub use crate::natural::NodeRemoveExtendedAttributeResponse;
17796
17797 pub use crate::natural::NodeSetExtendedAttributeResponse;
17798
17799 pub use crate::natural::NodeSetFlagsResponse;
17800
17801 pub use crate::natural::NodeSyncResponse;
17802
17803 pub use crate::natural::NodeUpdateAttributesResponse;
17804
17805 pub use crate::natural::OpenableOpenRequest;
17806
17807 pub use crate::natural::Representation;
17808
17809 pub use crate::natural::SymlinkInfo;
17810
17811 pub use ::fidl_next_fuchsia_unknown::natural::CloneableCloneRequest;
17812
17813 pub use ::fidl_next_fuchsia_unknown::natural::CloseableCloseResponse;
17814
17815 pub use ::fidl_next_fuchsia_unknown::natural::QueryableQueryResponse;
17816 }
17817
17818 pub struct LinkInto;
17819
17820 impl ::fidl_next::Method for LinkInto {
17821 const ORDINAL: u64 = 6121399674497678964;
17822 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17823 ::fidl_next::protocol::Flexibility::Strict;
17824
17825 type Protocol = crate::Symlink;
17826
17827 type Request = crate::wire::LinkableLinkIntoRequest<'static>;
17828 }
17829
17830 impl ::fidl_next::TwoWayMethod for LinkInto {
17831 type Response = ::fidl_next::wire::Result<
17832 'static,
17833 crate::wire::LinkableLinkIntoResponse,
17834 ::fidl_next::wire::fuchsia::Status,
17835 >;
17836 }
17837
17838 impl<___R> ::fidl_next::Respond<___R> for LinkInto {
17839 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17840
17841 fn respond(response: ___R) -> Self::Output {
17842 ::core::result::Result::Ok(response)
17843 }
17844 }
17845
17846 impl<___R> ::fidl_next::RespondErr<___R> for LinkInto {
17847 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17848
17849 fn respond_err(response: ___R) -> Self::Output {
17850 ::core::result::Result::Err(response)
17851 }
17852 }
17853
17854 pub struct Clone;
17855
17856 impl ::fidl_next::Method for Clone {
17857 const ORDINAL: u64 = 2366825959783828089;
17858 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17859 ::fidl_next::protocol::Flexibility::Strict;
17860
17861 type Protocol = crate::Symlink;
17862
17863 type Request = ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest;
17864 }
17865
17866 pub struct Close;
17867
17868 impl ::fidl_next::Method for Close {
17869 const ORDINAL: u64 = 6540867515453498750;
17870 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17871 ::fidl_next::protocol::Flexibility::Strict;
17872
17873 type Protocol = crate::Symlink;
17874
17875 type Request = ::fidl_next::wire::EmptyMessageBody;
17876 }
17877
17878 impl ::fidl_next::TwoWayMethod for Close {
17879 type Response = ::fidl_next::wire::Result<
17880 'static,
17881 ::fidl_next_fuchsia_unknown::wire::CloseableCloseResponse,
17882 ::fidl_next::wire::Int32,
17883 >;
17884 }
17885
17886 impl<___R> ::fidl_next::Respond<___R> for Close {
17887 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
17888
17889 fn respond(response: ___R) -> Self::Output {
17890 ::core::result::Result::Ok(response)
17891 }
17892 }
17893
17894 impl<___R> ::fidl_next::RespondErr<___R> for Close {
17895 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
17896
17897 fn respond_err(response: ___R) -> Self::Output {
17898 ::core::result::Result::Err(response)
17899 }
17900 }
17901
17902 pub struct Query;
17903
17904 impl ::fidl_next::Method for Query {
17905 const ORDINAL: u64 = 2763219980499352582;
17906 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17907 ::fidl_next::protocol::Flexibility::Strict;
17908
17909 type Protocol = crate::Symlink;
17910
17911 type Request = ::fidl_next::wire::EmptyMessageBody;
17912 }
17913
17914 impl ::fidl_next::TwoWayMethod for Query {
17915 type Response = ::fidl_next::wire::Strict<
17916 ::fidl_next_fuchsia_unknown::wire::QueryableQueryResponse<'static>,
17917 >;
17918 }
17919
17920 impl<___R> ::fidl_next::Respond<___R> for Query {
17921 type Output =
17922 ::fidl_next::Strict<::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse<___R>>;
17923
17924 fn respond(response: ___R) -> Self::Output {
17925 ::fidl_next::Strict(::fidl_next_fuchsia_unknown::generic::QueryableQueryResponse {
17926 protocol: response,
17927 })
17928 }
17929 }
17930
17931 pub struct OnOpen;
17932
17933 impl ::fidl_next::Method for OnOpen {
17934 const ORDINAL: u64 = 9207534335756671346;
17935 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17936 ::fidl_next::protocol::Flexibility::Flexible;
17937
17938 type Protocol = crate::Symlink;
17939
17940 type Request = crate::wire::NodeOnOpenRequest<'static>;
17941 }
17942
17943 pub struct DeprecatedGetAttr;
17944
17945 impl ::fidl_next::Method for DeprecatedGetAttr {
17946 const ORDINAL: u64 = 8689798978500614909;
17947 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17948 ::fidl_next::protocol::Flexibility::Strict;
17949
17950 type Protocol = crate::Symlink;
17951
17952 type Request = ::fidl_next::wire::EmptyMessageBody;
17953 }
17954
17955 impl ::fidl_next::TwoWayMethod for DeprecatedGetAttr {
17956 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetAttrResponse>;
17957 }
17958
17959 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetAttr {
17960 type Output = ::fidl_next::Strict<___R>;
17961
17962 fn respond(response: ___R) -> Self::Output {
17963 ::fidl_next::Strict(response)
17964 }
17965 }
17966
17967 pub struct DeprecatedSetAttr;
17968
17969 impl ::fidl_next::Method for DeprecatedSetAttr {
17970 const ORDINAL: u64 = 4721673413776871238;
17971 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17972 ::fidl_next::protocol::Flexibility::Strict;
17973
17974 type Protocol = crate::Symlink;
17975
17976 type Request = crate::wire::NodeDeprecatedSetAttrRequest;
17977 }
17978
17979 impl ::fidl_next::TwoWayMethod for DeprecatedSetAttr {
17980 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetAttrResponse>;
17981 }
17982
17983 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetAttr {
17984 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetAttrResponse<___R>>;
17985
17986 fn respond(response: ___R) -> Self::Output {
17987 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetAttrResponse { s: response })
17988 }
17989 }
17990
17991 pub struct DeprecatedGetFlags;
17992
17993 impl ::fidl_next::Method for DeprecatedGetFlags {
17994 const ORDINAL: u64 = 6595803110182632097;
17995 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
17996 ::fidl_next::protocol::Flexibility::Strict;
17997
17998 type Protocol = crate::Symlink;
17999
18000 type Request = ::fidl_next::wire::EmptyMessageBody;
18001 }
18002
18003 impl ::fidl_next::TwoWayMethod for DeprecatedGetFlags {
18004 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedGetFlagsResponse>;
18005 }
18006
18007 impl<___R> ::fidl_next::Respond<___R> for DeprecatedGetFlags {
18008 type Output = ::fidl_next::Strict<___R>;
18009
18010 fn respond(response: ___R) -> Self::Output {
18011 ::fidl_next::Strict(response)
18012 }
18013 }
18014
18015 pub struct DeprecatedSetFlags;
18016
18017 impl ::fidl_next::Method for DeprecatedSetFlags {
18018 const ORDINAL: u64 = 5950864159036794675;
18019 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18020 ::fidl_next::protocol::Flexibility::Strict;
18021
18022 type Protocol = crate::Symlink;
18023
18024 type Request = crate::wire::NodeDeprecatedSetFlagsRequest;
18025 }
18026
18027 impl ::fidl_next::TwoWayMethod for DeprecatedSetFlags {
18028 type Response = ::fidl_next::wire::Strict<crate::wire::NodeDeprecatedSetFlagsResponse>;
18029 }
18030
18031 impl<___R> ::fidl_next::Respond<___R> for DeprecatedSetFlags {
18032 type Output = ::fidl_next::Strict<crate::generic::NodeDeprecatedSetFlagsResponse<___R>>;
18033
18034 fn respond(response: ___R) -> Self::Output {
18035 ::fidl_next::Strict(crate::generic::NodeDeprecatedSetFlagsResponse { s: response })
18036 }
18037 }
18038
18039 pub struct GetFlags;
18040
18041 impl ::fidl_next::Method for GetFlags {
18042 const ORDINAL: u64 = 105530239381466147;
18043 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18044 ::fidl_next::protocol::Flexibility::Flexible;
18045
18046 type Protocol = crate::Symlink;
18047
18048 type Request = ::fidl_next::wire::EmptyMessageBody;
18049 }
18050
18051 impl ::fidl_next::TwoWayMethod for GetFlags {
18052 type Response = ::fidl_next::wire::Result<
18053 'static,
18054 crate::wire::NodeGetFlagsResponse,
18055 ::fidl_next::wire::fuchsia::Status,
18056 >;
18057 }
18058
18059 impl<___R> ::fidl_next::Respond<___R> for GetFlags {
18060 type Output = ::core::result::Result<
18061 crate::generic::NodeGetFlagsResponse<___R>,
18062 ::fidl_next::never::Never,
18063 >;
18064
18065 fn respond(response: ___R) -> Self::Output {
18066 ::core::result::Result::Ok(crate::generic::NodeGetFlagsResponse { flags: response })
18067 }
18068 }
18069
18070 impl<___R> ::fidl_next::RespondErr<___R> for GetFlags {
18071 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18072
18073 fn respond_err(response: ___R) -> Self::Output {
18074 ::core::result::Result::Err(response)
18075 }
18076 }
18077
18078 pub struct SetFlags;
18079
18080 impl ::fidl_next::Method for SetFlags {
18081 const ORDINAL: u64 = 6172186066099445416;
18082 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18083 ::fidl_next::protocol::Flexibility::Flexible;
18084
18085 type Protocol = crate::Symlink;
18086
18087 type Request = crate::wire::NodeSetFlagsRequest;
18088 }
18089
18090 impl ::fidl_next::TwoWayMethod for SetFlags {
18091 type Response = ::fidl_next::wire::Result<
18092 'static,
18093 crate::wire::NodeSetFlagsResponse,
18094 ::fidl_next::wire::fuchsia::Status,
18095 >;
18096 }
18097
18098 impl<___R> ::fidl_next::Respond<___R> for SetFlags {
18099 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18100
18101 fn respond(response: ___R) -> Self::Output {
18102 ::core::result::Result::Ok(response)
18103 }
18104 }
18105
18106 impl<___R> ::fidl_next::RespondErr<___R> for SetFlags {
18107 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18108
18109 fn respond_err(response: ___R) -> Self::Output {
18110 ::core::result::Result::Err(response)
18111 }
18112 }
18113
18114 pub struct QueryFilesystem;
18115
18116 impl ::fidl_next::Method for QueryFilesystem {
18117 const ORDINAL: u64 = 8013111122914313744;
18118 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18119 ::fidl_next::protocol::Flexibility::Strict;
18120
18121 type Protocol = crate::Symlink;
18122
18123 type Request = ::fidl_next::wire::EmptyMessageBody;
18124 }
18125
18126 impl ::fidl_next::TwoWayMethod for QueryFilesystem {
18127 type Response =
18128 ::fidl_next::wire::Strict<crate::wire::NodeQueryFilesystemResponse<'static>>;
18129 }
18130
18131 impl<___R> ::fidl_next::Respond<___R> for QueryFilesystem {
18132 type Output = ::fidl_next::Strict<___R>;
18133
18134 fn respond(response: ___R) -> Self::Output {
18135 ::fidl_next::Strict(response)
18136 }
18137 }
18138
18139 pub struct OnRepresentation;
18140
18141 impl ::fidl_next::Method for OnRepresentation {
18142 const ORDINAL: u64 = 6679970090861613324;
18143 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18144 ::fidl_next::protocol::Flexibility::Strict;
18145
18146 type Protocol = crate::Symlink;
18147
18148 type Request = crate::wire::Representation<'static>;
18149 }
18150
18151 pub struct GetToken;
18152
18153 impl ::fidl_next::Method for GetToken {
18154 const ORDINAL: u64 = 5788516050773961964;
18155 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18156 ::fidl_next::protocol::Flexibility::Flexible;
18157
18158 type Protocol = crate::Symlink;
18159
18160 type Request = ::fidl_next::wire::EmptyMessageBody;
18161 }
18162
18163 impl ::fidl_next::TwoWayMethod for GetToken {
18164 type Response = ::fidl_next::wire::Result<
18165 'static,
18166 crate::wire::NodeGetTokenResponse,
18167 ::fidl_next::wire::fuchsia::Status,
18168 >;
18169 }
18170
18171 impl<___R> ::fidl_next::Respond<___R> for GetToken {
18172 type Output = ::core::result::Result<
18173 crate::generic::NodeGetTokenResponse<___R>,
18174 ::fidl_next::never::Never,
18175 >;
18176
18177 fn respond(response: ___R) -> Self::Output {
18178 ::core::result::Result::Ok(crate::generic::NodeGetTokenResponse { token: response })
18179 }
18180 }
18181
18182 impl<___R> ::fidl_next::RespondErr<___R> for GetToken {
18183 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18184
18185 fn respond_err(response: ___R) -> Self::Output {
18186 ::core::result::Result::Err(response)
18187 }
18188 }
18189
18190 pub struct GetAttributes;
18191
18192 impl ::fidl_next::Method for GetAttributes {
18193 const ORDINAL: u64 = 4414537700416816443;
18194 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18195 ::fidl_next::protocol::Flexibility::Strict;
18196
18197 type Protocol = crate::Symlink;
18198
18199 type Request = crate::wire::NodeGetAttributesRequest;
18200 }
18201
18202 impl ::fidl_next::TwoWayMethod for GetAttributes {
18203 type Response = ::fidl_next::wire::Result<
18204 'static,
18205 crate::wire::NodeAttributes2<'static>,
18206 ::fidl_next::wire::fuchsia::Status,
18207 >;
18208 }
18209
18210 impl<___R> ::fidl_next::Respond<___R> for GetAttributes {
18211 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18212
18213 fn respond(response: ___R) -> Self::Output {
18214 ::core::result::Result::Ok(response)
18215 }
18216 }
18217
18218 impl<___R> ::fidl_next::RespondErr<___R> for GetAttributes {
18219 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18220
18221 fn respond_err(response: ___R) -> Self::Output {
18222 ::core::result::Result::Err(response)
18223 }
18224 }
18225
18226 pub struct UpdateAttributes;
18227
18228 impl ::fidl_next::Method for UpdateAttributes {
18229 const ORDINAL: u64 = 3677402239314018056;
18230 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18231 ::fidl_next::protocol::Flexibility::Strict;
18232
18233 type Protocol = crate::Symlink;
18234
18235 type Request = crate::wire::MutableNodeAttributes<'static>;
18236 }
18237
18238 impl ::fidl_next::TwoWayMethod for UpdateAttributes {
18239 type Response = ::fidl_next::wire::Result<
18240 'static,
18241 crate::wire::NodeUpdateAttributesResponse,
18242 ::fidl_next::wire::fuchsia::Status,
18243 >;
18244 }
18245
18246 impl<___R> ::fidl_next::Respond<___R> for UpdateAttributes {
18247 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18248
18249 fn respond(response: ___R) -> Self::Output {
18250 ::core::result::Result::Ok(response)
18251 }
18252 }
18253
18254 impl<___R> ::fidl_next::RespondErr<___R> for UpdateAttributes {
18255 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18256
18257 fn respond_err(response: ___R) -> Self::Output {
18258 ::core::result::Result::Err(response)
18259 }
18260 }
18261
18262 pub struct Sync;
18263
18264 impl ::fidl_next::Method for Sync {
18265 const ORDINAL: u64 = 3196473584242777161;
18266 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18267 ::fidl_next::protocol::Flexibility::Strict;
18268
18269 type Protocol = crate::Symlink;
18270
18271 type Request = ::fidl_next::wire::EmptyMessageBody;
18272 }
18273
18274 impl ::fidl_next::TwoWayMethod for Sync {
18275 type Response = ::fidl_next::wire::Result<
18276 'static,
18277 crate::wire::NodeSyncResponse,
18278 ::fidl_next::wire::fuchsia::Status,
18279 >;
18280 }
18281
18282 impl<___R> ::fidl_next::Respond<___R> for Sync {
18283 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18284
18285 fn respond(response: ___R) -> Self::Output {
18286 ::core::result::Result::Ok(response)
18287 }
18288 }
18289
18290 impl<___R> ::fidl_next::RespondErr<___R> for Sync {
18291 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18292
18293 fn respond_err(response: ___R) -> Self::Output {
18294 ::core::result::Result::Err(response)
18295 }
18296 }
18297
18298 pub struct ListExtendedAttributes;
18299
18300 impl ::fidl_next::Method for ListExtendedAttributes {
18301 const ORDINAL: u64 = 5431626189872037072;
18302 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18303 ::fidl_next::protocol::Flexibility::Strict;
18304
18305 type Protocol = crate::Symlink;
18306
18307 type Request = crate::wire::NodeListExtendedAttributesRequest;
18308 }
18309
18310 pub struct GetExtendedAttribute;
18311
18312 impl ::fidl_next::Method for GetExtendedAttribute {
18313 const ORDINAL: u64 = 5043930208506967771;
18314 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18315 ::fidl_next::protocol::Flexibility::Strict;
18316
18317 type Protocol = crate::Symlink;
18318
18319 type Request = crate::wire::NodeGetExtendedAttributeRequest<'static>;
18320 }
18321
18322 impl ::fidl_next::TwoWayMethod for GetExtendedAttribute {
18323 type Response = ::fidl_next::wire::Result<
18324 'static,
18325 crate::wire::ExtendedAttributeValue<'static>,
18326 ::fidl_next::wire::fuchsia::Status,
18327 >;
18328 }
18329
18330 impl<___R> ::fidl_next::Respond<___R> for GetExtendedAttribute {
18331 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18332
18333 fn respond(response: ___R) -> Self::Output {
18334 ::core::result::Result::Ok(response)
18335 }
18336 }
18337
18338 impl<___R> ::fidl_next::RespondErr<___R> for GetExtendedAttribute {
18339 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18340
18341 fn respond_err(response: ___R) -> Self::Output {
18342 ::core::result::Result::Err(response)
18343 }
18344 }
18345
18346 pub struct SetExtendedAttribute;
18347
18348 impl ::fidl_next::Method for SetExtendedAttribute {
18349 const ORDINAL: u64 = 5374223046099989052;
18350 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18351 ::fidl_next::protocol::Flexibility::Strict;
18352
18353 type Protocol = crate::Symlink;
18354
18355 type Request = crate::wire::NodeSetExtendedAttributeRequest<'static>;
18356 }
18357
18358 impl ::fidl_next::TwoWayMethod for SetExtendedAttribute {
18359 type Response = ::fidl_next::wire::Result<
18360 'static,
18361 crate::wire::NodeSetExtendedAttributeResponse,
18362 ::fidl_next::wire::fuchsia::Status,
18363 >;
18364 }
18365
18366 impl<___R> ::fidl_next::Respond<___R> for SetExtendedAttribute {
18367 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18368
18369 fn respond(response: ___R) -> Self::Output {
18370 ::core::result::Result::Ok(response)
18371 }
18372 }
18373
18374 impl<___R> ::fidl_next::RespondErr<___R> for SetExtendedAttribute {
18375 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18376
18377 fn respond_err(response: ___R) -> Self::Output {
18378 ::core::result::Result::Err(response)
18379 }
18380 }
18381
18382 pub struct RemoveExtendedAttribute;
18383
18384 impl ::fidl_next::Method for RemoveExtendedAttribute {
18385 const ORDINAL: u64 = 8794297771444732717;
18386 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18387 ::fidl_next::protocol::Flexibility::Strict;
18388
18389 type Protocol = crate::Symlink;
18390
18391 type Request = crate::wire::NodeRemoveExtendedAttributeRequest<'static>;
18392 }
18393
18394 impl ::fidl_next::TwoWayMethod for RemoveExtendedAttribute {
18395 type Response = ::fidl_next::wire::Result<
18396 'static,
18397 crate::wire::NodeRemoveExtendedAttributeResponse,
18398 ::fidl_next::wire::fuchsia::Status,
18399 >;
18400 }
18401
18402 impl<___R> ::fidl_next::Respond<___R> for RemoveExtendedAttribute {
18403 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
18404
18405 fn respond(response: ___R) -> Self::Output {
18406 ::core::result::Result::Ok(response)
18407 }
18408 }
18409
18410 impl<___R> ::fidl_next::RespondErr<___R> for RemoveExtendedAttribute {
18411 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
18412
18413 fn respond_err(response: ___R) -> Self::Output {
18414 ::core::result::Result::Err(response)
18415 }
18416 }
18417
18418 pub struct Open;
18419
18420 impl ::fidl_next::Method for Open {
18421 const ORDINAL: u64 = 6236883748953765593;
18422 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18423 ::fidl_next::protocol::Flexibility::Flexible;
18424
18425 type Protocol = crate::Symlink;
18426
18427 type Request = crate::wire::OpenableOpenRequest<'static>;
18428 }
18429
18430 pub struct Describe;
18431
18432 impl ::fidl_next::Method for Describe {
18433 const ORDINAL: u64 = 8371117097481679347;
18434 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
18435 ::fidl_next::protocol::Flexibility::Flexible;
18436
18437 type Protocol = crate::Symlink;
18438
18439 type Request = ::fidl_next::wire::EmptyMessageBody;
18440 }
18441
18442 impl ::fidl_next::TwoWayMethod for Describe {
18443 type Response = ::fidl_next::wire::Flexible<'static, crate::wire::SymlinkInfo<'static>>;
18444 }
18445
18446 impl<___R> ::fidl_next::Respond<___R> for Describe {
18447 type Output = ::fidl_next::Flexible<___R>;
18448
18449 fn respond(response: ___R) -> Self::Output {
18450 ::fidl_next::Flexible(response)
18451 }
18452 }
18453
18454 mod ___detail {
18455 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Symlink
18456 where
18457 ___T: ::fidl_next::Transport,
18458 {
18459 type Client = SymlinkClient<___T>;
18460 type Server = SymlinkServer<___T>;
18461 }
18462
18463 #[repr(transparent)]
18465 pub struct SymlinkClient<___T: ::fidl_next::Transport> {
18466 #[allow(dead_code)]
18467 client: ::fidl_next::protocol::Client<___T>,
18468 }
18469
18470 impl<___T> SymlinkClient<___T>
18471 where
18472 ___T: ::fidl_next::Transport,
18473 {
18474 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
18475 pub fn link_into(
18476 &self,
18477
18478 dst_parent_token: impl ::fidl_next::Encode<
18479 ::fidl_next::wire::fuchsia::Event,
18480 <___T as ::fidl_next::Transport>::SendBuffer,
18481 >,
18482
18483 dst: impl ::fidl_next::Encode<
18484 ::fidl_next::wire::String<'static>,
18485 <___T as ::fidl_next::Transport>::SendBuffer,
18486 >,
18487 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
18488 where
18489 <___T as ::fidl_next::Transport>::SendBuffer:
18490 ::fidl_next::encoder::InternalHandleEncoder,
18491 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18492 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18493 {
18494 self.link_into_with(crate::generic::LinkableLinkIntoRequest {
18495 dst_parent_token,
18496
18497 dst,
18498 })
18499 }
18500
18501 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
18502 pub fn link_into_with<___R>(
18503 &self,
18504 request: ___R,
18505 ) -> ::fidl_next::TwoWayFuture<'_, super::LinkInto, ___T>
18506 where
18507 ___R: ::fidl_next::Encode<
18508 crate::wire::LinkableLinkIntoRequest<'static>,
18509 <___T as ::fidl_next::Transport>::SendBuffer,
18510 >,
18511 {
18512 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18513 6121399674497678964,
18514 <super::LinkInto as ::fidl_next::Method>::FLEXIBILITY,
18515 request,
18516 ))
18517 }
18518
18519 pub fn clone(
18520 &self,
18521
18522 request: impl ::fidl_next::Encode<
18523 ::fidl_next::ServerEnd<
18524 ::fidl_next_fuchsia_unknown::Cloneable,
18525 ::fidl_next::wire::fuchsia::Channel,
18526 >,
18527 <___T as ::fidl_next::Transport>::SendBuffer,
18528 >,
18529 ) -> ::fidl_next::SendFuture<'_, ___T>
18530 where
18531 <___T as ::fidl_next::Transport>::SendBuffer:
18532 ::fidl_next::encoder::InternalHandleEncoder,
18533 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18534 {
18535 self.clone_with(::fidl_next_fuchsia_unknown::generic::CloneableCloneRequest {
18536 request,
18537 })
18538 }
18539
18540 pub fn clone_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
18541 where
18542 ___R: ::fidl_next::Encode<
18543 ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest,
18544 <___T as ::fidl_next::Transport>::SendBuffer,
18545 >,
18546 {
18547 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18548 2366825959783828089,
18549 <super::Clone as ::fidl_next::Method>::FLEXIBILITY,
18550 request,
18551 ))
18552 }
18553
18554 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
18555 pub fn close(&self) -> ::fidl_next::TwoWayFuture<'_, super::Close, ___T> {
18556 ::fidl_next::TwoWayFuture::from_untyped(
18557 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18558 6540867515453498750,
18559 <super::Close as ::fidl_next::Method>::FLEXIBILITY,
18560 (),
18561 ),
18562 )
18563 }
18564
18565 pub fn query(&self) -> ::fidl_next::TwoWayFuture<'_, super::Query, ___T> {
18566 ::fidl_next::TwoWayFuture::from_untyped(
18567 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18568 2763219980499352582,
18569 <super::Query as ::fidl_next::Method>::FLEXIBILITY,
18570 (),
18571 ),
18572 )
18573 }
18574
18575 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
18576 pub fn deprecated_get_attr(
18577 &self,
18578 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetAttr, ___T> {
18579 ::fidl_next::TwoWayFuture::from_untyped(
18580 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18581 8689798978500614909,
18582 <super::DeprecatedGetAttr as ::fidl_next::Method>::FLEXIBILITY,
18583 (),
18584 ),
18585 )
18586 }
18587
18588 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18589 pub fn deprecated_set_attr(
18590 &self,
18591
18592 flags: impl ::fidl_next::Encode<
18593 crate::wire::NodeAttributeFlags,
18594 <___T as ::fidl_next::Transport>::SendBuffer,
18595 >,
18596
18597 attributes: impl ::fidl_next::Encode<
18598 crate::wire::NodeAttributes,
18599 <___T as ::fidl_next::Transport>::SendBuffer,
18600 >,
18601 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18602 where
18603 <___T as ::fidl_next::Transport>::SendBuffer:
18604 ::fidl_next::encoder::InternalHandleEncoder,
18605 {
18606 self.deprecated_set_attr_with(crate::generic::NodeDeprecatedSetAttrRequest {
18607 flags,
18608
18609 attributes,
18610 })
18611 }
18612
18613 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
18614 pub fn deprecated_set_attr_with<___R>(
18615 &self,
18616 request: ___R,
18617 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetAttr, ___T>
18618 where
18619 ___R: ::fidl_next::Encode<
18620 crate::wire::NodeDeprecatedSetAttrRequest,
18621 <___T as ::fidl_next::Transport>::SendBuffer,
18622 >,
18623 {
18624 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18625 4721673413776871238,
18626 <super::DeprecatedSetAttr as ::fidl_next::Method>::FLEXIBILITY,
18627 request,
18628 ))
18629 }
18630
18631 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
18632 pub fn deprecated_get_flags(
18633 &self,
18634 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedGetFlags, ___T> {
18635 ::fidl_next::TwoWayFuture::from_untyped(
18636 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18637 6595803110182632097,
18638 <super::DeprecatedGetFlags as ::fidl_next::Method>::FLEXIBILITY,
18639 (),
18640 ),
18641 )
18642 }
18643
18644 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18645 pub fn deprecated_set_flags(
18646 &self,
18647
18648 flags: impl ::fidl_next::Encode<
18649 crate::wire::OpenFlags,
18650 <___T as ::fidl_next::Transport>::SendBuffer,
18651 >,
18652 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18653 where
18654 <___T as ::fidl_next::Transport>::SendBuffer:
18655 ::fidl_next::encoder::InternalHandleEncoder,
18656 {
18657 self.deprecated_set_flags_with(crate::generic::NodeDeprecatedSetFlagsRequest {
18658 flags,
18659 })
18660 }
18661
18662 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
18663 pub fn deprecated_set_flags_with<___R>(
18664 &self,
18665 request: ___R,
18666 ) -> ::fidl_next::TwoWayFuture<'_, super::DeprecatedSetFlags, ___T>
18667 where
18668 ___R: ::fidl_next::Encode<
18669 crate::wire::NodeDeprecatedSetFlagsRequest,
18670 <___T as ::fidl_next::Transport>::SendBuffer,
18671 >,
18672 {
18673 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18674 5950864159036794675,
18675 <super::DeprecatedSetFlags as ::fidl_next::Method>::FLEXIBILITY,
18676 request,
18677 ))
18678 }
18679
18680 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
18681 pub fn get_flags(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetFlags, ___T> {
18682 ::fidl_next::TwoWayFuture::from_untyped(
18683 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18684 105530239381466147,
18685 <super::GetFlags as ::fidl_next::Method>::FLEXIBILITY,
18686 (),
18687 ),
18688 )
18689 }
18690
18691 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
18692 pub fn set_flags(
18693 &self,
18694
18695 flags: impl ::fidl_next::Encode<
18696 crate::wire::Flags,
18697 <___T as ::fidl_next::Transport>::SendBuffer,
18698 >,
18699 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18700 where
18701 <___T as ::fidl_next::Transport>::SendBuffer:
18702 ::fidl_next::encoder::InternalHandleEncoder,
18703 {
18704 self.set_flags_with(crate::generic::NodeSetFlagsRequest { flags })
18705 }
18706
18707 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
18708 pub fn set_flags_with<___R>(
18709 &self,
18710 request: ___R,
18711 ) -> ::fidl_next::TwoWayFuture<'_, super::SetFlags, ___T>
18712 where
18713 ___R: ::fidl_next::Encode<
18714 crate::wire::NodeSetFlagsRequest,
18715 <___T as ::fidl_next::Transport>::SendBuffer,
18716 >,
18717 {
18718 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18719 6172186066099445416,
18720 <super::SetFlags as ::fidl_next::Method>::FLEXIBILITY,
18721 request,
18722 ))
18723 }
18724
18725 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
18726 pub fn query_filesystem(
18727 &self,
18728 ) -> ::fidl_next::TwoWayFuture<'_, super::QueryFilesystem, ___T> {
18729 ::fidl_next::TwoWayFuture::from_untyped(
18730 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18731 8013111122914313744,
18732 <super::QueryFilesystem as ::fidl_next::Method>::FLEXIBILITY,
18733 (),
18734 ),
18735 )
18736 }
18737
18738 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
18739 pub fn get_token(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetToken, ___T> {
18740 ::fidl_next::TwoWayFuture::from_untyped(
18741 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18742 5788516050773961964,
18743 <super::GetToken as ::fidl_next::Method>::FLEXIBILITY,
18744 (),
18745 ),
18746 )
18747 }
18748
18749 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
18750 pub fn get_attributes(
18751 &self,
18752
18753 query: impl ::fidl_next::Encode<
18754 crate::wire::NodeAttributesQuery,
18755 <___T as ::fidl_next::Transport>::SendBuffer,
18756 >,
18757 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18758 where
18759 <___T as ::fidl_next::Transport>::SendBuffer:
18760 ::fidl_next::encoder::InternalHandleEncoder,
18761 {
18762 self.get_attributes_with(crate::generic::NodeGetAttributesRequest { query })
18763 }
18764
18765 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
18766 pub fn get_attributes_with<___R>(
18767 &self,
18768 request: ___R,
18769 ) -> ::fidl_next::TwoWayFuture<'_, super::GetAttributes, ___T>
18770 where
18771 ___R: ::fidl_next::Encode<
18772 crate::wire::NodeGetAttributesRequest,
18773 <___T as ::fidl_next::Transport>::SendBuffer,
18774 >,
18775 {
18776 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18777 4414537700416816443,
18778 <super::GetAttributes as ::fidl_next::Method>::FLEXIBILITY,
18779 request,
18780 ))
18781 }
18782
18783 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
18784 pub fn update_attributes_with<___R>(
18785 &self,
18786 request: ___R,
18787 ) -> ::fidl_next::TwoWayFuture<'_, super::UpdateAttributes, ___T>
18788 where
18789 ___R: ::fidl_next::Encode<
18790 crate::wire::MutableNodeAttributes<'static>,
18791 <___T as ::fidl_next::Transport>::SendBuffer,
18792 >,
18793 {
18794 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18795 3677402239314018056,
18796 <super::UpdateAttributes as ::fidl_next::Method>::FLEXIBILITY,
18797 request,
18798 ))
18799 }
18800
18801 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
18802 pub fn sync(&self) -> ::fidl_next::TwoWayFuture<'_, super::Sync, ___T> {
18803 ::fidl_next::TwoWayFuture::from_untyped(
18804 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
18805 3196473584242777161,
18806 <super::Sync as ::fidl_next::Method>::FLEXIBILITY,
18807 (),
18808 ),
18809 )
18810 }
18811
18812 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
18813 pub fn list_extended_attributes(
18814 &self,
18815
18816 iterator: impl ::fidl_next::Encode<
18817 ::fidl_next::ServerEnd<
18818 crate::ExtendedAttributeIterator,
18819 ::fidl_next::wire::fuchsia::Channel,
18820 >,
18821 <___T as ::fidl_next::Transport>::SendBuffer,
18822 >,
18823 ) -> ::fidl_next::SendFuture<'_, ___T>
18824 where
18825 <___T as ::fidl_next::Transport>::SendBuffer:
18826 ::fidl_next::encoder::InternalHandleEncoder,
18827 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18828 {
18829 self.list_extended_attributes_with(
18830 crate::generic::NodeListExtendedAttributesRequest { iterator },
18831 )
18832 }
18833
18834 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
18835 pub fn list_extended_attributes_with<___R>(
18836 &self,
18837 request: ___R,
18838 ) -> ::fidl_next::SendFuture<'_, ___T>
18839 where
18840 ___R: ::fidl_next::Encode<
18841 crate::wire::NodeListExtendedAttributesRequest,
18842 <___T as ::fidl_next::Transport>::SendBuffer,
18843 >,
18844 {
18845 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
18846 5431626189872037072,
18847 <super::ListExtendedAttributes as ::fidl_next::Method>::FLEXIBILITY,
18848 request,
18849 ))
18850 }
18851
18852 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
18853 pub fn get_extended_attribute(
18854 &self,
18855
18856 name: impl ::fidl_next::Encode<
18857 ::fidl_next::wire::Vector<'static, u8>,
18858 <___T as ::fidl_next::Transport>::SendBuffer,
18859 >,
18860 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18861 where
18862 <___T as ::fidl_next::Transport>::SendBuffer:
18863 ::fidl_next::encoder::InternalHandleEncoder,
18864 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18865 {
18866 self.get_extended_attribute_with(crate::generic::NodeGetExtendedAttributeRequest {
18867 name,
18868 })
18869 }
18870
18871 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
18872 pub fn get_extended_attribute_with<___R>(
18873 &self,
18874 request: ___R,
18875 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExtendedAttribute, ___T>
18876 where
18877 ___R: ::fidl_next::Encode<
18878 crate::wire::NodeGetExtendedAttributeRequest<'static>,
18879 <___T as ::fidl_next::Transport>::SendBuffer,
18880 >,
18881 {
18882 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18883 5043930208506967771,
18884 <super::GetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18885 request,
18886 ))
18887 }
18888
18889 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18890 pub fn set_extended_attribute(
18891 &self,
18892
18893 name: impl ::fidl_next::Encode<
18894 ::fidl_next::wire::Vector<'static, u8>,
18895 <___T as ::fidl_next::Transport>::SendBuffer,
18896 >,
18897
18898 value: impl ::fidl_next::Encode<
18899 crate::wire::ExtendedAttributeValue<'static>,
18900 <___T as ::fidl_next::Transport>::SendBuffer,
18901 >,
18902
18903 mode: impl ::fidl_next::Encode<
18904 crate::wire::SetExtendedAttributeMode,
18905 <___T as ::fidl_next::Transport>::SendBuffer,
18906 >,
18907 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18908 where
18909 <___T as ::fidl_next::Transport>::SendBuffer:
18910 ::fidl_next::encoder::InternalHandleEncoder,
18911 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18912 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
18913 {
18914 self.set_extended_attribute_with(crate::generic::NodeSetExtendedAttributeRequest {
18915 name,
18916
18917 value,
18918
18919 mode,
18920 })
18921 }
18922
18923 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18924 pub fn set_extended_attribute_with<___R>(
18925 &self,
18926 request: ___R,
18927 ) -> ::fidl_next::TwoWayFuture<'_, super::SetExtendedAttribute, ___T>
18928 where
18929 ___R: ::fidl_next::Encode<
18930 crate::wire::NodeSetExtendedAttributeRequest<'static>,
18931 <___T as ::fidl_next::Transport>::SendBuffer,
18932 >,
18933 {
18934 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18935 5374223046099989052,
18936 <super::SetExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18937 request,
18938 ))
18939 }
18940
18941 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18942 pub fn remove_extended_attribute(
18943 &self,
18944
18945 name: impl ::fidl_next::Encode<
18946 ::fidl_next::wire::Vector<'static, u8>,
18947 <___T as ::fidl_next::Transport>::SendBuffer,
18948 >,
18949 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18950 where
18951 <___T as ::fidl_next::Transport>::SendBuffer:
18952 ::fidl_next::encoder::InternalHandleEncoder,
18953 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
18954 {
18955 self.remove_extended_attribute_with(
18956 crate::generic::NodeRemoveExtendedAttributeRequest { name },
18957 )
18958 }
18959
18960 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
18961 pub fn remove_extended_attribute_with<___R>(
18962 &self,
18963 request: ___R,
18964 ) -> ::fidl_next::TwoWayFuture<'_, super::RemoveExtendedAttribute, ___T>
18965 where
18966 ___R: ::fidl_next::Encode<
18967 crate::wire::NodeRemoveExtendedAttributeRequest<'static>,
18968 <___T as ::fidl_next::Transport>::SendBuffer,
18969 >,
18970 {
18971 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
18972 8794297771444732717,
18973 <super::RemoveExtendedAttribute as ::fidl_next::Method>::FLEXIBILITY,
18974 request,
18975 ))
18976 }
18977
18978 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
18979 pub fn open(
18980 &self,
18981
18982 path: impl ::fidl_next::Encode<
18983 ::fidl_next::wire::String<'static>,
18984 <___T as ::fidl_next::Transport>::SendBuffer,
18985 >,
18986
18987 flags: impl ::fidl_next::Encode<
18988 crate::wire::Flags,
18989 <___T as ::fidl_next::Transport>::SendBuffer,
18990 >,
18991
18992 options: impl ::fidl_next::Encode<
18993 crate::wire::Options<'static>,
18994 <___T as ::fidl_next::Transport>::SendBuffer,
18995 >,
18996
18997 object: impl ::fidl_next::Encode<
18998 ::fidl_next::wire::fuchsia::Channel,
18999 <___T as ::fidl_next::Transport>::SendBuffer,
19000 >,
19001 ) -> ::fidl_next::SendFuture<'_, ___T>
19002 where
19003 <___T as ::fidl_next::Transport>::SendBuffer:
19004 ::fidl_next::encoder::InternalHandleEncoder,
19005 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
19006 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
19007 {
19008 self.open_with(crate::generic::OpenableOpenRequest { path, flags, options, object })
19009 }
19010
19011 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
19012 pub fn open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
19013 where
19014 ___R: ::fidl_next::Encode<
19015 crate::wire::OpenableOpenRequest<'static>,
19016 <___T as ::fidl_next::Transport>::SendBuffer,
19017 >,
19018 {
19019 ::fidl_next::SendFuture::from_untyped(self.client.send_one_way(
19020 6236883748953765593,
19021 <super::Open as ::fidl_next::Method>::FLEXIBILITY,
19022 request,
19023 ))
19024 }
19025
19026 pub fn describe(&self) -> ::fidl_next::TwoWayFuture<'_, super::Describe, ___T> {
19027 ::fidl_next::TwoWayFuture::from_untyped(
19028 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
19029 8371117097481679347,
19030 <super::Describe as ::fidl_next::Method>::FLEXIBILITY,
19031 (),
19032 ),
19033 )
19034 }
19035 }
19036
19037 #[repr(transparent)]
19039 pub struct SymlinkServer<___T: ::fidl_next::Transport> {
19040 server: ::fidl_next::protocol::Server<___T>,
19041 }
19042
19043 impl<___T> SymlinkServer<___T>
19044 where
19045 ___T: ::fidl_next::Transport,
19046 {
19047 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
19048 pub fn on_open(
19049 &self,
19050
19051 s: impl ::fidl_next::Encode<
19052 ::fidl_next::wire::fuchsia::StatusResult,
19053 <___T as ::fidl_next::Transport>::SendBuffer,
19054 >,
19055
19056 info: impl ::fidl_next::Encode<
19057 crate::wire_optional::NodeInfoDeprecated<'static>,
19058 <___T as ::fidl_next::Transport>::SendBuffer,
19059 >,
19060 ) -> ::fidl_next::SendFuture<'_, ___T>
19061 where
19062 <___T as ::fidl_next::Transport>::SendBuffer:
19063 ::fidl_next::encoder::InternalHandleEncoder,
19064 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
19065 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
19066 {
19067 self.on_open_with(crate::generic::NodeOnOpenRequest { s, info })
19068 }
19069
19070 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
19071
19072 pub fn on_open_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
19073 where
19074 ___R: ::fidl_next::Encode<
19075 <super::OnOpen as ::fidl_next::Method>::Request,
19076 <___T as ::fidl_next::Transport>::SendBuffer,
19077 >,
19078 {
19079 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
19080 9207534335756671346,
19081 <super::OnOpen as ::fidl_next::Method>::FLEXIBILITY,
19082 request,
19083 ))
19084 }
19085
19086 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
19087
19088 pub fn on_representation_with<___R>(
19089 &self,
19090 request: ___R,
19091 ) -> ::fidl_next::SendFuture<'_, ___T>
19092 where
19093 ___R: ::fidl_next::Encode<
19094 <super::OnRepresentation as ::fidl_next::Method>::Request,
19095 <___T as ::fidl_next::Transport>::SendBuffer,
19096 >,
19097 {
19098 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
19099 6679970090861613324,
19100 <super::OnRepresentation as ::fidl_next::Method>::FLEXIBILITY,
19101 request,
19102 ))
19103 }
19104 }
19105 }
19106}
19107
19108#[diagnostic::on_unimplemented(
19109 note = "If {Self} implements the non-local SymlinkClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
19110)]
19111
19112pub trait SymlinkLocalClientHandler<
19116 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19117 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19118>
19119{
19120 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
19121 fn on_open(
19122 &mut self,
19123
19124 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19125 ) -> impl ::core::future::Future<Output = ()>;
19126
19127 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
19128 fn on_representation(
19129 &mut self,
19130
19131 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19132 ) -> impl ::core::future::Future<Output = ()>;
19133
19134 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
19135 ::core::future::ready(())
19136 }
19137}
19138
19139impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Symlink
19140where
19141 ___H: SymlinkLocalClientHandler<___T>,
19142 ___T: ::fidl_next::Transport,
19143 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19144 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19145 Constraint = (),
19146 >,
19147 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19148 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19149 Constraint = (),
19150 >,
19151{
19152 async fn on_event(
19153 handler: &mut ___H,
19154 mut message: ::fidl_next::Message<___T>,
19155 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19156 match *message.header().ordinal {
19157 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19158 Ok(decoded) => {
19159 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19160 Ok(())
19161 }
19162 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19163 ordinal: 9207534335756671346,
19164 error,
19165 }),
19166 },
19167
19168 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19169 Ok(decoded) => {
19170 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19171 Ok(())
19172 }
19173 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19174 ordinal: 6679970090861613324,
19175 error,
19176 }),
19177 },
19178
19179 ordinal => {
19180 handler.on_unknown_interaction(ordinal).await;
19181 if ::core::matches!(
19182 message.header().flexibility(),
19183 ::fidl_next::protocol::Flexibility::Strict
19184 ) {
19185 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19186 } else {
19187 Ok(())
19188 }
19189 }
19190 }
19191 }
19192}
19193
19194#[diagnostic::on_unimplemented(
19195 note = "If {Self} implements the non-local SymlinkServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
19196)]
19197
19198pub trait SymlinkLocalServerHandler<
19202 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19203 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19204>
19205{
19206 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
19207 fn link_into(
19208 &mut self,
19209
19210 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19211
19212 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19213 ) -> impl ::core::future::Future<Output = ()>;
19214
19215 fn clone(
19216 &mut self,
19217
19218 request: ::fidl_next::Request<symlink::Clone, ___T>,
19219 ) -> impl ::core::future::Future<Output = ()>;
19220
19221 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
19222 fn close(
19223 &mut self,
19224
19225 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19226 ) -> impl ::core::future::Future<Output = ()>;
19227
19228 fn query(
19229 &mut self,
19230
19231 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19232 ) -> impl ::core::future::Future<Output = ()>;
19233
19234 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19235 fn deprecated_get_attr(
19236 &mut self,
19237
19238 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19239 ) -> impl ::core::future::Future<Output = ()>;
19240
19241 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19242 fn deprecated_set_attr(
19243 &mut self,
19244
19245 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19246
19247 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19248 ) -> impl ::core::future::Future<Output = ()>;
19249
19250 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19251 fn deprecated_get_flags(
19252 &mut self,
19253
19254 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19255 ) -> impl ::core::future::Future<Output = ()>;
19256
19257 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19258 fn deprecated_set_flags(
19259 &mut self,
19260
19261 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19262
19263 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19264 ) -> impl ::core::future::Future<Output = ()>;
19265
19266 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
19267 fn get_flags(
19268 &mut self,
19269
19270 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19271 ) -> impl ::core::future::Future<Output = ()>;
19272
19273 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
19274 fn set_flags(
19275 &mut self,
19276
19277 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19278
19279 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19280 ) -> impl ::core::future::Future<Output = ()>;
19281
19282 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
19283 fn query_filesystem(
19284 &mut self,
19285
19286 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19287 ) -> impl ::core::future::Future<Output = ()>;
19288
19289 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
19290 fn get_token(
19291 &mut self,
19292
19293 responder: ::fidl_next::Responder<symlink::GetToken, ___T>,
19294 ) -> impl ::core::future::Future<Output = ()>;
19295
19296 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19297 fn get_attributes(
19298 &mut self,
19299
19300 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19301
19302 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19303 ) -> impl ::core::future::Future<Output = ()>;
19304
19305 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
19306 fn update_attributes(
19307 &mut self,
19308
19309 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19310
19311 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19312 ) -> impl ::core::future::Future<Output = ()>;
19313
19314 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
19315 fn sync(
19316 &mut self,
19317
19318 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19319 ) -> impl ::core::future::Future<Output = ()>;
19320
19321 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
19322 fn list_extended_attributes(
19323 &mut self,
19324
19325 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19326 ) -> impl ::core::future::Future<Output = ()>;
19327
19328 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
19329 fn get_extended_attribute(
19330 &mut self,
19331
19332 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19333
19334 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19335 ) -> impl ::core::future::Future<Output = ()>;
19336
19337 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
19338 fn set_extended_attribute(
19339 &mut self,
19340
19341 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
19342
19343 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
19344 ) -> impl ::core::future::Future<Output = ()>;
19345
19346 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
19347 fn remove_extended_attribute(
19348 &mut self,
19349
19350 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
19351
19352 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
19353 ) -> impl ::core::future::Future<Output = ()>;
19354
19355 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
19356 fn open(
19357 &mut self,
19358
19359 request: ::fidl_next::Request<symlink::Open, ___T>,
19360 ) -> impl ::core::future::Future<Output = ()>;
19361
19362 fn describe(
19363 &mut self,
19364
19365 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
19366 ) -> impl ::core::future::Future<Output = ()>;
19367
19368 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
19369 ::core::future::ready(())
19370 }
19371}
19372
19373impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Symlink
19374where
19375 ___H: SymlinkLocalServerHandler<___T>,
19376 ___T: ::fidl_next::Transport,
19377 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
19378 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19379 Constraint = (),
19380 >,
19381 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
19382 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19383 Constraint = (),
19384 >,
19385 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
19386 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19387 Constraint = (),
19388 >,
19389 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
19390 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19391 Constraint = (),
19392 >,
19393 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
19394 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19395 Constraint = (),
19396 >,
19397 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
19398 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19399 Constraint = (),
19400 >,
19401 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
19402 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19403 Constraint = (),
19404 >,
19405 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
19406 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19407 Constraint = (),
19408 >,
19409 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19410 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19411 Constraint = (),
19412 >,
19413 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19414 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19415 Constraint = (),
19416 >,
19417 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
19418 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19419 Constraint = (),
19420 >,
19421 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
19422 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19423 Constraint = (),
19424 >,
19425{
19426 async fn on_one_way(
19427 handler: &mut ___H,
19428 mut message: ::fidl_next::Message<___T>,
19429 ) -> ::core::result::Result<
19430 (),
19431 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19432 > {
19433 match *message.header().ordinal {
19434 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19435 Ok(decoded) => {
19436 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
19437 Ok(())
19438 }
19439 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19440 ordinal: 2366825959783828089,
19441 error,
19442 }),
19443 },
19444
19445 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19446 Ok(decoded) => {
19447 handler
19448 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
19449 .await;
19450 Ok(())
19451 }
19452 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19453 ordinal: 5431626189872037072,
19454 error,
19455 }),
19456 },
19457
19458 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19459 Ok(decoded) => {
19460 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
19461 Ok(())
19462 }
19463 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19464 ordinal: 6236883748953765593,
19465 error,
19466 }),
19467 },
19468
19469 ordinal => {
19470 handler.on_unknown_interaction(ordinal).await;
19471 if ::core::matches!(
19472 message.header().flexibility(),
19473 ::fidl_next::protocol::Flexibility::Strict
19474 ) {
19475 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19476 } else {
19477 Ok(())
19478 }
19479 }
19480 }
19481 }
19482
19483 async fn on_two_way(
19484 handler: &mut ___H,
19485 mut message: ::fidl_next::Message<___T>,
19486 responder: ::fidl_next::protocol::Responder<___T>,
19487 ) -> ::core::result::Result<
19488 (),
19489 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
19490 > {
19491 match *message.header().ordinal {
19492 6121399674497678964 => {
19493 let responder = ::fidl_next::Responder::from_untyped(responder);
19494
19495 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19496 Ok(decoded) => {
19497 handler
19498 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
19499 .await;
19500 Ok(())
19501 }
19502 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19503 ordinal: 6121399674497678964,
19504 error,
19505 }),
19506 }
19507 }
19508
19509 6540867515453498750 => {
19510 let responder = ::fidl_next::Responder::from_untyped(responder);
19511
19512 handler.close(responder).await;
19513 Ok(())
19514 }
19515
19516 2763219980499352582 => {
19517 let responder = ::fidl_next::Responder::from_untyped(responder);
19518
19519 handler.query(responder).await;
19520 Ok(())
19521 }
19522
19523 8689798978500614909 => {
19524 let responder = ::fidl_next::Responder::from_untyped(responder);
19525
19526 handler.deprecated_get_attr(responder).await;
19527 Ok(())
19528 }
19529
19530 4721673413776871238 => {
19531 let responder = ::fidl_next::Responder::from_untyped(responder);
19532
19533 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19534 Ok(decoded) => {
19535 handler
19536 .deprecated_set_attr(
19537 ::fidl_next::Request::from_decoded(decoded),
19538 responder,
19539 )
19540 .await;
19541 Ok(())
19542 }
19543 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19544 ordinal: 4721673413776871238,
19545 error,
19546 }),
19547 }
19548 }
19549
19550 6595803110182632097 => {
19551 let responder = ::fidl_next::Responder::from_untyped(responder);
19552
19553 handler.deprecated_get_flags(responder).await;
19554 Ok(())
19555 }
19556
19557 5950864159036794675 => {
19558 let responder = ::fidl_next::Responder::from_untyped(responder);
19559
19560 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19561 Ok(decoded) => {
19562 handler
19563 .deprecated_set_flags(
19564 ::fidl_next::Request::from_decoded(decoded),
19565 responder,
19566 )
19567 .await;
19568 Ok(())
19569 }
19570 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19571 ordinal: 5950864159036794675,
19572 error,
19573 }),
19574 }
19575 }
19576
19577 105530239381466147 => {
19578 let responder = ::fidl_next::Responder::from_untyped(responder);
19579
19580 handler.get_flags(responder).await;
19581 Ok(())
19582 }
19583
19584 6172186066099445416 => {
19585 let responder = ::fidl_next::Responder::from_untyped(responder);
19586
19587 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19588 Ok(decoded) => {
19589 handler
19590 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
19591 .await;
19592 Ok(())
19593 }
19594 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19595 ordinal: 6172186066099445416,
19596 error,
19597 }),
19598 }
19599 }
19600
19601 8013111122914313744 => {
19602 let responder = ::fidl_next::Responder::from_untyped(responder);
19603
19604 handler.query_filesystem(responder).await;
19605 Ok(())
19606 }
19607
19608 5788516050773961964 => {
19609 let responder = ::fidl_next::Responder::from_untyped(responder);
19610
19611 handler.get_token(responder).await;
19612 Ok(())
19613 }
19614
19615 4414537700416816443 => {
19616 let responder = ::fidl_next::Responder::from_untyped(responder);
19617
19618 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19619 Ok(decoded) => {
19620 handler
19621 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
19622 .await;
19623 Ok(())
19624 }
19625 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19626 ordinal: 4414537700416816443,
19627 error,
19628 }),
19629 }
19630 }
19631
19632 3677402239314018056 => {
19633 let responder = ::fidl_next::Responder::from_untyped(responder);
19634
19635 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19636 Ok(decoded) => {
19637 handler
19638 .update_attributes(
19639 ::fidl_next::Request::from_decoded(decoded),
19640 responder,
19641 )
19642 .await;
19643 Ok(())
19644 }
19645 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19646 ordinal: 3677402239314018056,
19647 error,
19648 }),
19649 }
19650 }
19651
19652 3196473584242777161 => {
19653 let responder = ::fidl_next::Responder::from_untyped(responder);
19654
19655 handler.sync(responder).await;
19656 Ok(())
19657 }
19658
19659 5043930208506967771 => {
19660 let responder = ::fidl_next::Responder::from_untyped(responder);
19661
19662 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19663 Ok(decoded) => {
19664 handler
19665 .get_extended_attribute(
19666 ::fidl_next::Request::from_decoded(decoded),
19667 responder,
19668 )
19669 .await;
19670 Ok(())
19671 }
19672 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19673 ordinal: 5043930208506967771,
19674 error,
19675 }),
19676 }
19677 }
19678
19679 5374223046099989052 => {
19680 let responder = ::fidl_next::Responder::from_untyped(responder);
19681
19682 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19683 Ok(decoded) => {
19684 handler
19685 .set_extended_attribute(
19686 ::fidl_next::Request::from_decoded(decoded),
19687 responder,
19688 )
19689 .await;
19690 Ok(())
19691 }
19692 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19693 ordinal: 5374223046099989052,
19694 error,
19695 }),
19696 }
19697 }
19698
19699 8794297771444732717 => {
19700 let responder = ::fidl_next::Responder::from_untyped(responder);
19701
19702 match ::fidl_next::AsDecoderExt::into_decoded(message) {
19703 Ok(decoded) => {
19704 handler
19705 .remove_extended_attribute(
19706 ::fidl_next::Request::from_decoded(decoded),
19707 responder,
19708 )
19709 .await;
19710 Ok(())
19711 }
19712 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19713 ordinal: 8794297771444732717,
19714 error,
19715 }),
19716 }
19717 }
19718
19719 8371117097481679347 => {
19720 let responder = ::fidl_next::Responder::from_untyped(responder);
19721
19722 handler.describe(responder).await;
19723 Ok(())
19724 }
19725
19726 ordinal => {
19727 handler.on_unknown_interaction(ordinal).await;
19728 if ::core::matches!(
19729 message.header().flexibility(),
19730 ::fidl_next::protocol::Flexibility::Strict
19731 ) {
19732 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19733 } else {
19734 responder
19735 .respond_framework_error(
19736 ordinal,
19737 ::fidl_next::FrameworkError::UnknownMethod,
19738 )
19739 .expect("encoding a framework error should never fail")
19740 .await?;
19741 Ok(())
19742 }
19743 }
19744 }
19745 }
19746}
19747
19748pub trait SymlinkClientHandler<
19752 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19753 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19754>
19755{
19756 #[doc = " An event produced eagerly by a FIDL server if requested by `OpenFlags.DESCRIBE`.\n\n Indicates the success or failure of the open operation, and optionally describes the\n object. If the status is `ZX_OK`, `info` contains descriptive information about the object\n (the same as would be returned by `Describe`).\n"]
19757 fn on_open(
19758 &mut self,
19759
19760 request: ::fidl_next::Request<symlink::OnOpen, ___T>,
19761 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19762
19763 #[doc = " An event produced eagerly by the server if requested by [`Flags.FLAG_SEND_REPRESENTATION`].\n This event will be sent as the first message from the server, and is sent exactly once.\n\n The active variant corresponds to the negotiated protocol for the target node (i.e. the\n protocol which this channel now speaks). Additionally, auxiliary handles and requested\n attributes are also returned in the event.\n"]
19764 fn on_representation(
19765 &mut self,
19766
19767 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
19768 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19769
19770 fn on_unknown_interaction(
19771 &mut self,
19772 ordinal: u64,
19773 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
19774 ::core::future::ready(())
19775 }
19776}
19777
19778impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Symlink
19779where
19780 ___H: SymlinkClientHandler<___T> + ::core::marker::Send,
19781 ___T: ::fidl_next::Transport,
19782 for<'de> crate::wire::NodeOnOpenRequest<'de>: ::fidl_next::Decode<
19783 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19784 Constraint = (),
19785 >,
19786 for<'de> crate::wire::Representation<'de>: ::fidl_next::Decode<
19787 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
19788 Constraint = (),
19789 >,
19790{
19791 async fn on_event(
19792 handler: &mut ___H,
19793 mut message: ::fidl_next::Message<___T>,
19794 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
19795 match *message.header().ordinal {
19796 9207534335756671346 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19797 Ok(decoded) => {
19798 handler.on_open(::fidl_next::Request::from_decoded(decoded)).await;
19799 Ok(())
19800 }
19801 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19802 ordinal: 9207534335756671346,
19803 error,
19804 }),
19805 },
19806
19807 6679970090861613324 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
19808 Ok(decoded) => {
19809 handler.on_representation(::fidl_next::Request::from_decoded(decoded)).await;
19810 Ok(())
19811 }
19812 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
19813 ordinal: 6679970090861613324,
19814 error,
19815 }),
19816 },
19817
19818 ordinal => {
19819 handler.on_unknown_interaction(ordinal).await;
19820 if ::core::matches!(
19821 message.header().flexibility(),
19822 ::fidl_next::protocol::Flexibility::Strict
19823 ) {
19824 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
19825 } else {
19826 Ok(())
19827 }
19828 }
19829 }
19830 }
19831}
19832
19833pub trait SymlinkServerHandler<
19837 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
19838 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
19839>
19840{
19841 #[doc = " Creates a link to this this object with name `dst` in the directory represented by\n `dst_parent_token`.\n\n `dst` must be a resolved object name. Including \"/\" in the string will return\n `ZX_ERR_INVALID_ARGS`.\n\n This method requires the maximal set of rights supported by the filesystem for this object.\n For files this would typically be [`Rights.READ_BYTES`], [`Rights.WRITE_BYTES`],\n [`Rights.GET_ATTRIBUTES`] and [`Rights.UPDATE_ATTRIBUTES`]. Some filesystems might also\n support the [`Rights.EXECUTE`] right. Insufficient rights will result in\n `ZX_ERR_ACCESS_DENIED`.\n\n If this object has no links and is *NOT* an unnamed temporary object (objects opened with\n `Flags.FLAG_CREATE_AS_UNNAMED_TEMPORARY`), it will fail with `ZX_ERR_NOT_FOUND`.\n\n For unnamed temporary objects, use LinkInto to give it a name. Upon successful completion,\n the object will be permanently linked to the filesystem. Requires that the unnamed temporary\n object is linkable, if not, it will fail with `ZX_ERR_NOT_FOUND`.\n\n This method does not have the same atomicity properties has the `Directory::Link` method,\n which means that calling `Open` then `LinkInto` is not equivalent to `Directory::Link`\n because `LinkInto` will not prevent the source from being renamed or unlinked.\n"]
19842 fn link_into(
19843 &mut self,
19844
19845 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
19846
19847 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
19848 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19849
19850 fn clone(
19851 &mut self,
19852
19853 request: ::fidl_next::Request<symlink::Clone, ___T>,
19854 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19855
19856 #[doc = " Terminates the connection.\n\n After calling `Close`, the client must not send any other requests.\n\n Servers, after sending the status response, should close the connection\n regardless of status and without sending an epitaph.\n\n Closing the client end of the channel should be semantically equivalent\n to calling `Close` without knowing when the close has completed or its\n status.\n"]
19857 fn close(
19858 &mut self,
19859
19860 responder: ::fidl_next::Responder<symlink::Close, ___T>,
19861 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19862
19863 fn query(
19864 &mut self,
19865
19866 responder: ::fidl_next::Responder<symlink::Query, ___T>,
19867 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19868
19869 #[doc = " DEPRECATED - Use `Node.GetAttributes` instead.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19870 fn deprecated_get_attr(
19871 &mut self,
19872
19873 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
19874 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19875
19876 #[doc = " DEPRECATED - Use `Node.UpdateAttributes` instead.\n"]
19877 fn deprecated_set_attr(
19878 &mut self,
19879
19880 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
19881
19882 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
19883 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19884
19885 #[doc = " [DEPRECATED - Use new GetFlags method instead.]\n"]
19886 fn deprecated_get_flags(
19887 &mut self,
19888
19889 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
19890 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19891
19892 #[doc = " [DEPRECATED - Use new SetFlags method instead.]\n"]
19893 fn deprecated_set_flags(
19894 &mut self,
19895
19896 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
19897
19898 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
19899 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19900
19901 #[doc = " Queries the flags that apply to this node after it has been opened/created. This method does\n not require any rights.\n\n Note that the final set of flags that apply to the connection may differ from those\n specified with the `fuchsia.io/Directory.Open` request used to create it:\n - `Flags.PERM_INHERIT_*`: Only applies when determining connection rights.\n - `Flags.PROTOCOL_*`: Only the protocol of the connection will be present.\n - `Flags.FLAG_*`: Only applies when opening the resource, not part of the connection.\n"]
19902 fn get_flags(
19903 &mut self,
19904
19905 responder: ::fidl_next::Responder<symlink::GetFlags, ___T>,
19906 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19907
19908 #[doc = " Sets the flags that apply to this node after it has been opened. This method does not\n require any rights.\n\n Only `Flags.FILE_APPEND` is currently supported. Calling this method without any flags will\n clear append mode.\n\n Errors:\n - `ZX_ERR_NOT_SUPPORTED`: The object does not support this feature or the specified flags.\n - `ZX_ERR_INVALID_ARGS`: `flags` other than `Flags.FILE_APPEND` were specified.\n"]
19909 fn set_flags(
19910 &mut self,
19911
19912 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
19913
19914 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
19915 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19916
19917 #[doc = " Query the filesystem for details specific to the filesystem and/or volume. If the current\n volume has different settings or the storage is accounted seperately from the rest of the\n filesystem that may be reported instead of filesystem-wide details.\n"]
19918 fn query_filesystem(
19919 &mut self,
19920
19921 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
19922 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19923
19924 #[doc = " Acquires a token which can be used to identify this connection at a later point in\n time. The token will remain valid for as long as the connection requesting the token\n remains open.\n\n This method does not require any rights. Note that the token identifies\n the connection, hence carries the rights information on this connection.\n"]
19925 fn get_token(
19926 &mut self,
19927
19928 responder: ::fidl_next::Responder<symlink::GetToken, ___T>,
19929 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19930
19931 #[doc = " Acquires information about the node.\n\n The attributes of a node should be stable, independent of the\n specific protocol used to access it.\n\n If a particular attribute is not applicable or not supported,\n filesystems should leave the corresponding field absent.\n\n + `query` a bit-mask specifying which attributes to fetch. The server\n should not return more than necessary.\n - `attributes` the returned attributes.\n\n This method requires the [`Rights.GET_ATTRIBUTES`] right.\n"]
19932 fn get_attributes(
19933 &mut self,
19934
19935 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
19936
19937 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
19938 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19939
19940 #[doc = " Updates information about the node.\n\n + `attributes` the presence of a table field in `attributes` indicates\n the intent to update the corresponding attribute.\n\n Returns `ZX_ERR_NOT_SUPPORTED` if the node does not support any of the specified attributes.\n\n This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.\n"]
19941 fn update_attributes(
19942 &mut self,
19943
19944 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
19945
19946 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
19947 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19948
19949 #[doc = " Synchronizes updates to the node to the underlying media, if it exists.\n\n This method will return when the filesystem server has flushed the\n relevant updates to the underlying media, but does not guarantee the\n underlying media has persisted the information, nor that any information\n is committed to hardware. Clients may use `Sync` to ensure ordering\n between operations.\n\n This method does not require any rights.\n"]
19950 fn sync(
19951 &mut self,
19952
19953 responder: ::fidl_next::Responder<symlink::Sync, ___T>,
19954 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19955
19956 #[doc = " Creates an iterator over all the extended attribute names associated\n with this node. If an error occurs it is returned as an epitaph on the\n iterator request channel, and then the channel is closed.\n\n GetExtendedAttributes can be used with any of these names to retrieve\n the associated value.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
19957 fn list_extended_attributes(
19958 &mut self,
19959
19960 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
19961 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19962
19963 #[doc = " Get the value associated with the given attribute `name` for this node.\n\n Attribute names have a maximum length of MAX_ATTRIBUTE_NAME. No\n particular structure is imposed on them.\n\n This method requires the [`Rights.READ_BYTES`] right.\n"]
19964 fn get_extended_attribute(
19965 &mut self,
19966
19967 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
19968
19969 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
19970 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19971
19972 #[doc = " Set the value for the given attribute `name` to `value` for this node.\n\n The attribute name may exist, in which case the attribute is updated.\n If the attribute doesn\'t exist, it is created. The name should have no\n null bytes in it. If it does, ZX_ERR_INVALID_ARGS is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
19973 fn set_extended_attribute(
19974 &mut self,
19975
19976 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
19977
19978 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
19979 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19980
19981 #[doc = " Remove the specified extended attribute.\n\n If the attribute doesn\'t exist, ZX_ERR_NOT_FOUND is returned.\n\n This method requires the [`Rights.WRITE_BYTES`] right.\n"]
19982 fn remove_extended_attribute(
19983 &mut self,
19984
19985 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
19986
19987 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
19988 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19989
19990 #[doc = " Open (or create) a node relative to this directory. Any errors are communicated via an\n epitaph sent on the `object` channel.\n\n Errors:\n * `ZX_ERR_BAD_PATH` if `path` is invalid\n * See [`Flags`] for other errors which may be communicated based on `flags`\n"]
19991 fn open(
19992 &mut self,
19993
19994 request: ::fidl_next::Request<symlink::Open, ___T>,
19995 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
19996
19997 fn describe(
19998 &mut self,
19999
20000 responder: ::fidl_next::Responder<symlink::Describe, ___T>,
20001 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
20002
20003 fn on_unknown_interaction(
20004 &mut self,
20005 ordinal: u64,
20006 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
20007 ::core::future::ready(())
20008 }
20009}
20010
20011impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Symlink
20012where
20013 ___H: SymlinkServerHandler<___T> + ::core::marker::Send,
20014 ___T: ::fidl_next::Transport,
20015 for<'de> crate::wire::LinkableLinkIntoRequest<'de>: ::fidl_next::Decode<
20016 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20017 Constraint = (),
20018 >,
20019 for<'de> ::fidl_next_fuchsia_unknown::wire::CloneableCloneRequest: ::fidl_next::Decode<
20020 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20021 Constraint = (),
20022 >,
20023 for<'de> crate::wire::NodeDeprecatedSetAttrRequest: ::fidl_next::Decode<
20024 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20025 Constraint = (),
20026 >,
20027 for<'de> crate::wire::NodeDeprecatedSetFlagsRequest: ::fidl_next::Decode<
20028 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20029 Constraint = (),
20030 >,
20031 for<'de> crate::wire::NodeSetFlagsRequest: ::fidl_next::Decode<
20032 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20033 Constraint = (),
20034 >,
20035 for<'de> crate::wire::NodeGetAttributesRequest: ::fidl_next::Decode<
20036 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20037 Constraint = (),
20038 >,
20039 for<'de> crate::wire::MutableNodeAttributes<'de>: ::fidl_next::Decode<
20040 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20041 Constraint = (),
20042 >,
20043 for<'de> crate::wire::NodeListExtendedAttributesRequest: ::fidl_next::Decode<
20044 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20045 Constraint = (),
20046 >,
20047 for<'de> crate::wire::NodeGetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20048 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20049 Constraint = (),
20050 >,
20051 for<'de> crate::wire::NodeSetExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20052 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20053 Constraint = (),
20054 >,
20055 for<'de> crate::wire::NodeRemoveExtendedAttributeRequest<'de>: ::fidl_next::Decode<
20056 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20057 Constraint = (),
20058 >,
20059 for<'de> crate::wire::OpenableOpenRequest<'de>: ::fidl_next::Decode<
20060 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
20061 Constraint = (),
20062 >,
20063{
20064 async fn on_one_way(
20065 handler: &mut ___H,
20066 mut message: ::fidl_next::Message<___T>,
20067 ) -> ::core::result::Result<
20068 (),
20069 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20070 > {
20071 match *message.header().ordinal {
20072 2366825959783828089 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20073 Ok(decoded) => {
20074 handler.clone(::fidl_next::Request::from_decoded(decoded)).await;
20075 Ok(())
20076 }
20077 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20078 ordinal: 2366825959783828089,
20079 error,
20080 }),
20081 },
20082
20083 5431626189872037072 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20084 Ok(decoded) => {
20085 handler
20086 .list_extended_attributes(::fidl_next::Request::from_decoded(decoded))
20087 .await;
20088 Ok(())
20089 }
20090 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20091 ordinal: 5431626189872037072,
20092 error,
20093 }),
20094 },
20095
20096 6236883748953765593 => match ::fidl_next::AsDecoderExt::into_decoded(message) {
20097 Ok(decoded) => {
20098 handler.open(::fidl_next::Request::from_decoded(decoded)).await;
20099 Ok(())
20100 }
20101 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20102 ordinal: 6236883748953765593,
20103 error,
20104 }),
20105 },
20106
20107 ordinal => {
20108 handler.on_unknown_interaction(ordinal).await;
20109 if ::core::matches!(
20110 message.header().flexibility(),
20111 ::fidl_next::protocol::Flexibility::Strict
20112 ) {
20113 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20114 } else {
20115 Ok(())
20116 }
20117 }
20118 }
20119 }
20120
20121 async fn on_two_way(
20122 handler: &mut ___H,
20123 mut message: ::fidl_next::Message<___T>,
20124 responder: ::fidl_next::protocol::Responder<___T>,
20125 ) -> ::core::result::Result<
20126 (),
20127 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
20128 > {
20129 match *message.header().ordinal {
20130 6121399674497678964 => {
20131 let responder = ::fidl_next::Responder::from_untyped(responder);
20132
20133 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20134 Ok(decoded) => {
20135 handler
20136 .link_into(::fidl_next::Request::from_decoded(decoded), responder)
20137 .await;
20138 Ok(())
20139 }
20140 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20141 ordinal: 6121399674497678964,
20142 error,
20143 }),
20144 }
20145 }
20146
20147 6540867515453498750 => {
20148 let responder = ::fidl_next::Responder::from_untyped(responder);
20149
20150 handler.close(responder).await;
20151 Ok(())
20152 }
20153
20154 2763219980499352582 => {
20155 let responder = ::fidl_next::Responder::from_untyped(responder);
20156
20157 handler.query(responder).await;
20158 Ok(())
20159 }
20160
20161 8689798978500614909 => {
20162 let responder = ::fidl_next::Responder::from_untyped(responder);
20163
20164 handler.deprecated_get_attr(responder).await;
20165 Ok(())
20166 }
20167
20168 4721673413776871238 => {
20169 let responder = ::fidl_next::Responder::from_untyped(responder);
20170
20171 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20172 Ok(decoded) => {
20173 handler
20174 .deprecated_set_attr(
20175 ::fidl_next::Request::from_decoded(decoded),
20176 responder,
20177 )
20178 .await;
20179 Ok(())
20180 }
20181 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20182 ordinal: 4721673413776871238,
20183 error,
20184 }),
20185 }
20186 }
20187
20188 6595803110182632097 => {
20189 let responder = ::fidl_next::Responder::from_untyped(responder);
20190
20191 handler.deprecated_get_flags(responder).await;
20192 Ok(())
20193 }
20194
20195 5950864159036794675 => {
20196 let responder = ::fidl_next::Responder::from_untyped(responder);
20197
20198 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20199 Ok(decoded) => {
20200 handler
20201 .deprecated_set_flags(
20202 ::fidl_next::Request::from_decoded(decoded),
20203 responder,
20204 )
20205 .await;
20206 Ok(())
20207 }
20208 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20209 ordinal: 5950864159036794675,
20210 error,
20211 }),
20212 }
20213 }
20214
20215 105530239381466147 => {
20216 let responder = ::fidl_next::Responder::from_untyped(responder);
20217
20218 handler.get_flags(responder).await;
20219 Ok(())
20220 }
20221
20222 6172186066099445416 => {
20223 let responder = ::fidl_next::Responder::from_untyped(responder);
20224
20225 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20226 Ok(decoded) => {
20227 handler
20228 .set_flags(::fidl_next::Request::from_decoded(decoded), responder)
20229 .await;
20230 Ok(())
20231 }
20232 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20233 ordinal: 6172186066099445416,
20234 error,
20235 }),
20236 }
20237 }
20238
20239 8013111122914313744 => {
20240 let responder = ::fidl_next::Responder::from_untyped(responder);
20241
20242 handler.query_filesystem(responder).await;
20243 Ok(())
20244 }
20245
20246 5788516050773961964 => {
20247 let responder = ::fidl_next::Responder::from_untyped(responder);
20248
20249 handler.get_token(responder).await;
20250 Ok(())
20251 }
20252
20253 4414537700416816443 => {
20254 let responder = ::fidl_next::Responder::from_untyped(responder);
20255
20256 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20257 Ok(decoded) => {
20258 handler
20259 .get_attributes(::fidl_next::Request::from_decoded(decoded), responder)
20260 .await;
20261 Ok(())
20262 }
20263 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20264 ordinal: 4414537700416816443,
20265 error,
20266 }),
20267 }
20268 }
20269
20270 3677402239314018056 => {
20271 let responder = ::fidl_next::Responder::from_untyped(responder);
20272
20273 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20274 Ok(decoded) => {
20275 handler
20276 .update_attributes(
20277 ::fidl_next::Request::from_decoded(decoded),
20278 responder,
20279 )
20280 .await;
20281 Ok(())
20282 }
20283 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20284 ordinal: 3677402239314018056,
20285 error,
20286 }),
20287 }
20288 }
20289
20290 3196473584242777161 => {
20291 let responder = ::fidl_next::Responder::from_untyped(responder);
20292
20293 handler.sync(responder).await;
20294 Ok(())
20295 }
20296
20297 5043930208506967771 => {
20298 let responder = ::fidl_next::Responder::from_untyped(responder);
20299
20300 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20301 Ok(decoded) => {
20302 handler
20303 .get_extended_attribute(
20304 ::fidl_next::Request::from_decoded(decoded),
20305 responder,
20306 )
20307 .await;
20308 Ok(())
20309 }
20310 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20311 ordinal: 5043930208506967771,
20312 error,
20313 }),
20314 }
20315 }
20316
20317 5374223046099989052 => {
20318 let responder = ::fidl_next::Responder::from_untyped(responder);
20319
20320 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20321 Ok(decoded) => {
20322 handler
20323 .set_extended_attribute(
20324 ::fidl_next::Request::from_decoded(decoded),
20325 responder,
20326 )
20327 .await;
20328 Ok(())
20329 }
20330 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20331 ordinal: 5374223046099989052,
20332 error,
20333 }),
20334 }
20335 }
20336
20337 8794297771444732717 => {
20338 let responder = ::fidl_next::Responder::from_untyped(responder);
20339
20340 match ::fidl_next::AsDecoderExt::into_decoded(message) {
20341 Ok(decoded) => {
20342 handler
20343 .remove_extended_attribute(
20344 ::fidl_next::Request::from_decoded(decoded),
20345 responder,
20346 )
20347 .await;
20348 Ok(())
20349 }
20350 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
20351 ordinal: 8794297771444732717,
20352 error,
20353 }),
20354 }
20355 }
20356
20357 8371117097481679347 => {
20358 let responder = ::fidl_next::Responder::from_untyped(responder);
20359
20360 handler.describe(responder).await;
20361 Ok(())
20362 }
20363
20364 ordinal => {
20365 handler.on_unknown_interaction(ordinal).await;
20366 if ::core::matches!(
20367 message.header().flexibility(),
20368 ::fidl_next::protocol::Flexibility::Strict
20369 ) {
20370 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
20371 } else {
20372 responder
20373 .respond_framework_error(
20374 ordinal,
20375 ::fidl_next::FrameworkError::UnknownMethod,
20376 )
20377 .expect("encoding a framework error should never fail")
20378 .await?;
20379 Ok(())
20380 }
20381 }
20382 }
20383 }
20384}
20385
20386impl<___T> SymlinkClientHandler<___T> for ::fidl_next::IgnoreEvents
20387where
20388 ___T: ::fidl_next::Transport,
20389{
20390 async fn on_open(&mut self, _: ::fidl_next::Request<symlink::OnOpen, ___T>) {}
20391
20392 async fn on_representation(
20393 &mut self,
20394
20395 _: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
20396 ) {
20397 }
20398
20399 async fn on_unknown_interaction(&mut self, _: u64) {}
20400}
20401
20402impl<___H, ___T> SymlinkLocalClientHandler<___T> for ::fidl_next::Local<___H>
20403where
20404 ___H: SymlinkClientHandler<___T>,
20405 ___T: ::fidl_next::Transport,
20406{
20407 async fn on_open(&mut self, request: ::fidl_next::Request<symlink::OnOpen, ___T>) {
20408 ___H::on_open(&mut self.0, request).await
20409 }
20410
20411 async fn on_representation(
20412 &mut self,
20413
20414 request: ::fidl_next::Request<symlink::OnRepresentation, ___T>,
20415 ) {
20416 ___H::on_representation(&mut self.0, request).await
20417 }
20418
20419 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20420 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20421 }
20422}
20423
20424impl<___H, ___T> SymlinkLocalServerHandler<___T> for ::fidl_next::Local<___H>
20425where
20426 ___H: SymlinkServerHandler<___T>,
20427 ___T: ::fidl_next::Transport,
20428{
20429 async fn link_into(
20430 &mut self,
20431
20432 request: ::fidl_next::Request<symlink::LinkInto, ___T>,
20433
20434 responder: ::fidl_next::Responder<symlink::LinkInto, ___T>,
20435 ) {
20436 ___H::link_into(&mut self.0, request, responder).await
20437 }
20438
20439 async fn clone(&mut self, request: ::fidl_next::Request<symlink::Clone, ___T>) {
20440 ___H::clone(&mut self.0, request).await
20441 }
20442
20443 async fn close(&mut self, responder: ::fidl_next::Responder<symlink::Close, ___T>) {
20444 ___H::close(&mut self.0, responder).await
20445 }
20446
20447 async fn query(&mut self, responder: ::fidl_next::Responder<symlink::Query, ___T>) {
20448 ___H::query(&mut self.0, responder).await
20449 }
20450
20451 async fn deprecated_get_attr(
20452 &mut self,
20453
20454 responder: ::fidl_next::Responder<symlink::DeprecatedGetAttr, ___T>,
20455 ) {
20456 ___H::deprecated_get_attr(&mut self.0, responder).await
20457 }
20458
20459 async fn deprecated_set_attr(
20460 &mut self,
20461
20462 request: ::fidl_next::Request<symlink::DeprecatedSetAttr, ___T>,
20463
20464 responder: ::fidl_next::Responder<symlink::DeprecatedSetAttr, ___T>,
20465 ) {
20466 ___H::deprecated_set_attr(&mut self.0, request, responder).await
20467 }
20468
20469 async fn deprecated_get_flags(
20470 &mut self,
20471
20472 responder: ::fidl_next::Responder<symlink::DeprecatedGetFlags, ___T>,
20473 ) {
20474 ___H::deprecated_get_flags(&mut self.0, responder).await
20475 }
20476
20477 async fn deprecated_set_flags(
20478 &mut self,
20479
20480 request: ::fidl_next::Request<symlink::DeprecatedSetFlags, ___T>,
20481
20482 responder: ::fidl_next::Responder<symlink::DeprecatedSetFlags, ___T>,
20483 ) {
20484 ___H::deprecated_set_flags(&mut self.0, request, responder).await
20485 }
20486
20487 async fn get_flags(&mut self, responder: ::fidl_next::Responder<symlink::GetFlags, ___T>) {
20488 ___H::get_flags(&mut self.0, responder).await
20489 }
20490
20491 async fn set_flags(
20492 &mut self,
20493
20494 request: ::fidl_next::Request<symlink::SetFlags, ___T>,
20495
20496 responder: ::fidl_next::Responder<symlink::SetFlags, ___T>,
20497 ) {
20498 ___H::set_flags(&mut self.0, request, responder).await
20499 }
20500
20501 async fn query_filesystem(
20502 &mut self,
20503
20504 responder: ::fidl_next::Responder<symlink::QueryFilesystem, ___T>,
20505 ) {
20506 ___H::query_filesystem(&mut self.0, responder).await
20507 }
20508
20509 async fn get_token(&mut self, responder: ::fidl_next::Responder<symlink::GetToken, ___T>) {
20510 ___H::get_token(&mut self.0, responder).await
20511 }
20512
20513 async fn get_attributes(
20514 &mut self,
20515
20516 request: ::fidl_next::Request<symlink::GetAttributes, ___T>,
20517
20518 responder: ::fidl_next::Responder<symlink::GetAttributes, ___T>,
20519 ) {
20520 ___H::get_attributes(&mut self.0, request, responder).await
20521 }
20522
20523 async fn update_attributes(
20524 &mut self,
20525
20526 request: ::fidl_next::Request<symlink::UpdateAttributes, ___T>,
20527
20528 responder: ::fidl_next::Responder<symlink::UpdateAttributes, ___T>,
20529 ) {
20530 ___H::update_attributes(&mut self.0, request, responder).await
20531 }
20532
20533 async fn sync(&mut self, responder: ::fidl_next::Responder<symlink::Sync, ___T>) {
20534 ___H::sync(&mut self.0, responder).await
20535 }
20536
20537 async fn list_extended_attributes(
20538 &mut self,
20539
20540 request: ::fidl_next::Request<symlink::ListExtendedAttributes, ___T>,
20541 ) {
20542 ___H::list_extended_attributes(&mut self.0, request).await
20543 }
20544
20545 async fn get_extended_attribute(
20546 &mut self,
20547
20548 request: ::fidl_next::Request<symlink::GetExtendedAttribute, ___T>,
20549
20550 responder: ::fidl_next::Responder<symlink::GetExtendedAttribute, ___T>,
20551 ) {
20552 ___H::get_extended_attribute(&mut self.0, request, responder).await
20553 }
20554
20555 async fn set_extended_attribute(
20556 &mut self,
20557
20558 request: ::fidl_next::Request<symlink::SetExtendedAttribute, ___T>,
20559
20560 responder: ::fidl_next::Responder<symlink::SetExtendedAttribute, ___T>,
20561 ) {
20562 ___H::set_extended_attribute(&mut self.0, request, responder).await
20563 }
20564
20565 async fn remove_extended_attribute(
20566 &mut self,
20567
20568 request: ::fidl_next::Request<symlink::RemoveExtendedAttribute, ___T>,
20569
20570 responder: ::fidl_next::Responder<symlink::RemoveExtendedAttribute, ___T>,
20571 ) {
20572 ___H::remove_extended_attribute(&mut self.0, request, responder).await
20573 }
20574
20575 async fn open(&mut self, request: ::fidl_next::Request<symlink::Open, ___T>) {
20576 ___H::open(&mut self.0, request).await
20577 }
20578
20579 async fn describe(&mut self, responder: ::fidl_next::Responder<symlink::Describe, ___T>) {
20580 ___H::describe(&mut self.0, responder).await
20581 }
20582
20583 async fn on_unknown_interaction(&mut self, ordinal: u64) {
20584 ___H::on_unknown_interaction(&mut self.0, ordinal).await
20585 }
20586}
20587
20588pub use fidl_next_common_fuchsia_io::*;