1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub type Name = ::std::string::String;
8
9 #[derive(Debug, Clone, PartialEq)]
10 pub struct ChildIteratorNextResponse {
11 pub children: ::std::vec::Vec<::fidl_next_common_fuchsia_component_decl::natural::ChildRef>,
12 }
13
14 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
15 for ChildIteratorNextResponse
16 where
17 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
18 ___E: ::fidl_next::Encoder,
19 {
20 #[inline]
21 fn encode(
22 self,
23 encoder_: &mut ___E,
24 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
25 _: (),
26 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
27 ::fidl_next::munge! {
28 let crate::wire::ChildIteratorNextResponse {
29 children,
30
31 } = out_;
32 }
33
34 ::fidl_next::Encode::encode(self.children, encoder_, children, (128, ()))?;
35
36 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(children.as_mut_ptr()) };
37 ::fidl_next::Constrained::validate(_field, (128, ()))?;
38
39 Ok(())
40 }
41 }
42
43 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
44 for &'a ChildIteratorNextResponse
45 where
46 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
47 ___E: ::fidl_next::Encoder,
48 {
49 #[inline]
50 fn encode(
51 self,
52 encoder_: &mut ___E,
53 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
54 _: (),
55 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
56 ::fidl_next::munge! {
57 let crate::wire::ChildIteratorNextResponse {
58 children,
59
60 } = out_;
61 }
62
63 ::fidl_next::Encode::encode(&self.children, encoder_, children, (128, ()))?;
64
65 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(children.as_mut_ptr()) };
66 ::fidl_next::Constrained::validate(_field, (128, ()))?;
67
68 Ok(())
69 }
70 }
71
72 unsafe impl<___E>
73 ::fidl_next::EncodeOption<
74 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
75 ___E,
76 > for ChildIteratorNextResponse
77 where
78 ___E: ::fidl_next::Encoder + ?Sized,
79 ChildIteratorNextResponse:
80 ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>,
81 {
82 #[inline]
83 fn encode_option(
84 this: ::core::option::Option<Self>,
85 encoder: &mut ___E,
86 out: &mut ::core::mem::MaybeUninit<
87 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
88 >,
89 _: (),
90 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
91 if let Some(inner) = this {
92 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
93 ::fidl_next::wire::Box::encode_present(out);
94 } else {
95 ::fidl_next::wire::Box::encode_absent(out);
96 }
97
98 Ok(())
99 }
100 }
101
102 unsafe impl<'a, ___E>
103 ::fidl_next::EncodeOption<
104 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
105 ___E,
106 > for &'a ChildIteratorNextResponse
107 where
108 ___E: ::fidl_next::Encoder + ?Sized,
109 &'a ChildIteratorNextResponse:
110 ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>,
111 {
112 #[inline]
113 fn encode_option(
114 this: ::core::option::Option<Self>,
115 encoder: &mut ___E,
116 out: &mut ::core::mem::MaybeUninit<
117 ::fidl_next::wire::Box<'static, crate::wire::ChildIteratorNextResponse<'static>>,
118 >,
119 _: (),
120 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
121 if let Some(inner) = this {
122 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
123 ::fidl_next::wire::Box::encode_present(out);
124 } else {
125 ::fidl_next::wire::Box::encode_absent(out);
126 }
127
128 Ok(())
129 }
130 }
131
132 impl<'de> ::fidl_next::FromWire<crate::wire::ChildIteratorNextResponse<'de>>
133 for ChildIteratorNextResponse
134 {
135 #[inline]
136 fn from_wire(wire: crate::wire::ChildIteratorNextResponse<'de>) -> Self {
137 Self { children: ::fidl_next::FromWire::from_wire(wire.children) }
138 }
139 }
140
141 impl<'de> ::fidl_next::FromWireRef<crate::wire::ChildIteratorNextResponse<'de>>
142 for ChildIteratorNextResponse
143 {
144 #[inline]
145 fn from_wire_ref(wire: &crate::wire::ChildIteratorNextResponse<'de>) -> Self {
146 Self { children: ::fidl_next::FromWireRef::from_wire_ref(&wire.children) }
147 }
148 }
149
150 pub type ControllerStartResponse = ();
151
152 #[doc = " Standard error codes for component framework protocols.\n"]
153 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
154 #[repr(u32)]
155 pub enum Error {
156 Internal = 1,
157 InvalidArguments = 2,
158 Unsupported = 3,
159 AccessDenied = 4,
160 InstanceNotFound = 5,
161 InstanceAlreadyExists = 6,
162 InstanceCannotStart = 7,
163 InstanceCannotResolve = 8,
164 CollectionNotFound = 9,
165 ResourceUnavailable = 10,
166 InstanceDied = 11,
167 ResourceNotFound = 12,
168 InstanceCannotUnresolve = 13,
169 InstanceAlreadyStarted = 14,
170 DependencyCycle = 15,
171 UnknownOrdinal_(u32) = 16,
172 }
173 impl ::std::convert::From<u32> for Error {
174 fn from(value: u32) -> Self {
175 match value {
176 1 => Self::Internal,
177 2 => Self::InvalidArguments,
178 3 => Self::Unsupported,
179 4 => Self::AccessDenied,
180 5 => Self::InstanceNotFound,
181 6 => Self::InstanceAlreadyExists,
182 7 => Self::InstanceCannotStart,
183 8 => Self::InstanceCannotResolve,
184 9 => Self::CollectionNotFound,
185 10 => Self::ResourceUnavailable,
186 11 => Self::InstanceDied,
187 12 => Self::ResourceNotFound,
188 13 => Self::InstanceCannotUnresolve,
189 14 => Self::InstanceAlreadyStarted,
190 15 => Self::DependencyCycle,
191
192 _ => Self::UnknownOrdinal_(value),
193 }
194 }
195 }
196
197 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Error, ___E> for Error
198 where
199 ___E: ?Sized,
200 {
201 #[inline]
202 fn encode(
203 self,
204 encoder: &mut ___E,
205 out: &mut ::core::mem::MaybeUninit<crate::wire::Error>,
206 _: (),
207 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
208 ::fidl_next::Encode::encode(&self, encoder, out, ())
209 }
210 }
211
212 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::Error, ___E> for &'a Error
213 where
214 ___E: ?Sized,
215 {
216 #[inline]
217 fn encode(
218 self,
219 encoder: &mut ___E,
220 out: &mut ::core::mem::MaybeUninit<crate::wire::Error>,
221 _: (),
222 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
223 ::fidl_next::munge!(let crate::wire::Error { value } = out);
224 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
225 Error::Internal => 1,
226
227 Error::InvalidArguments => 2,
228
229 Error::Unsupported => 3,
230
231 Error::AccessDenied => 4,
232
233 Error::InstanceNotFound => 5,
234
235 Error::InstanceAlreadyExists => 6,
236
237 Error::InstanceCannotStart => 7,
238
239 Error::InstanceCannotResolve => 8,
240
241 Error::CollectionNotFound => 9,
242
243 Error::ResourceUnavailable => 10,
244
245 Error::InstanceDied => 11,
246
247 Error::ResourceNotFound => 12,
248
249 Error::InstanceCannotUnresolve => 13,
250
251 Error::InstanceAlreadyStarted => 14,
252
253 Error::DependencyCycle => 15,
254
255 Error::UnknownOrdinal_(value) => value,
256 }));
257
258 Ok(())
259 }
260 }
261
262 impl ::core::convert::From<crate::wire::Error> for Error {
263 fn from(wire: crate::wire::Error) -> Self {
264 match u32::from(wire.value) {
265 1 => Self::Internal,
266
267 2 => Self::InvalidArguments,
268
269 3 => Self::Unsupported,
270
271 4 => Self::AccessDenied,
272
273 5 => Self::InstanceNotFound,
274
275 6 => Self::InstanceAlreadyExists,
276
277 7 => Self::InstanceCannotStart,
278
279 8 => Self::InstanceCannotResolve,
280
281 9 => Self::CollectionNotFound,
282
283 10 => Self::ResourceUnavailable,
284
285 11 => Self::InstanceDied,
286
287 12 => Self::ResourceNotFound,
288
289 13 => Self::InstanceCannotUnresolve,
290
291 14 => Self::InstanceAlreadyStarted,
292
293 15 => Self::DependencyCycle,
294
295 value => Self::UnknownOrdinal_(value),
296 }
297 }
298 }
299
300 impl ::fidl_next::FromWire<crate::wire::Error> for Error {
301 #[inline]
302 fn from_wire(wire: crate::wire::Error) -> Self {
303 Self::from(wire)
304 }
305 }
306
307 impl ::fidl_next::FromWireRef<crate::wire::Error> for Error {
308 #[inline]
309 fn from_wire_ref(wire: &crate::wire::Error) -> Self {
310 Self::from(*wire)
311 }
312 }
313
314 pub type ControllerOpenExposedDirResponse = ();
315
316 pub type ControllerDestroyResponse = ();
317
318 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
319 #[repr(u32)]
320 pub enum DeletionError {
321 Connection = 1,
322 Protocol = 2,
323 NoneAvailable = 3,
324 Unsupported = 4,
325 }
326 impl ::core::convert::TryFrom<u32> for DeletionError {
327 type Error = ::fidl_next::UnknownStrictEnumMemberError;
328 fn try_from(
329 value: u32,
330 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
331 match value {
332 1 => Ok(Self::Connection),
333 2 => Ok(Self::Protocol),
334 3 => Ok(Self::NoneAvailable),
335 4 => Ok(Self::Unsupported),
336
337 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
338 }
339 }
340 }
341
342 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DeletionError, ___E> for DeletionError
343 where
344 ___E: ?Sized,
345 {
346 #[inline]
347 fn encode(
348 self,
349 encoder: &mut ___E,
350 out: &mut ::core::mem::MaybeUninit<crate::wire::DeletionError>,
351 _: (),
352 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
353 ::fidl_next::Encode::encode(&self, encoder, out, ())
354 }
355 }
356
357 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DeletionError, ___E> for &'a DeletionError
358 where
359 ___E: ?Sized,
360 {
361 #[inline]
362 fn encode(
363 self,
364 encoder: &mut ___E,
365 out: &mut ::core::mem::MaybeUninit<crate::wire::DeletionError>,
366 _: (),
367 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
368 ::fidl_next::munge!(let crate::wire::DeletionError { value } = out);
369 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
370 DeletionError::Connection => 1,
371
372 DeletionError::Protocol => 2,
373
374 DeletionError::NoneAvailable => 3,
375
376 DeletionError::Unsupported => 4,
377 }));
378
379 Ok(())
380 }
381 }
382
383 impl ::core::convert::From<crate::wire::DeletionError> for DeletionError {
384 fn from(wire: crate::wire::DeletionError) -> Self {
385 match u32::from(wire.value) {
386 1 => Self::Connection,
387
388 2 => Self::Protocol,
389
390 3 => Self::NoneAvailable,
391
392 4 => Self::Unsupported,
393
394 _ => unsafe { ::core::hint::unreachable_unchecked() },
395 }
396 }
397 }
398
399 impl ::fidl_next::FromWire<crate::wire::DeletionError> for DeletionError {
400 #[inline]
401 fn from_wire(wire: crate::wire::DeletionError) -> Self {
402 Self::from(wire)
403 }
404 }
405
406 impl ::fidl_next::FromWireRef<crate::wire::DeletionError> for DeletionError {
407 #[inline]
408 fn from_wire_ref(wire: &crate::wire::DeletionError) -> Self {
409 Self::from(*wire)
410 }
411 }
412
413 #[doc = " Payload for Destroyed events.\n"]
414 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
415 pub struct DestroyedPayload {}
416
417 impl DestroyedPayload {
418 fn __max_ordinal(&self) -> usize {
419 0
420 }
421 }
422
423 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DestroyedPayload<'static>, ___E>
424 for DestroyedPayload
425 where
426 ___E: ::fidl_next::Encoder + ?Sized,
427 {
428 #[inline]
429 fn encode(
430 mut self,
431 encoder: &mut ___E,
432 out: &mut ::core::mem::MaybeUninit<crate::wire::DestroyedPayload<'static>>,
433 _: (),
434 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
435 ::fidl_next::munge!(let crate::wire::DestroyedPayload { table } = out);
436
437 let max_ord = self.__max_ordinal();
438
439 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
440 ::fidl_next::Wire::zero_padding(&mut out);
441
442 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
443 ::fidl_next::wire::Envelope,
444 >(encoder, max_ord);
445
446 for i in 1..=max_ord {
447 match i {
448 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
449 }
450 unsafe {
451 preallocated.write_next(out.assume_init_ref());
452 }
453 }
454
455 ::fidl_next::wire::Table::encode_len(table, max_ord);
456
457 Ok(())
458 }
459 }
460
461 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DestroyedPayload<'static>, ___E>
462 for &'a DestroyedPayload
463 where
464 ___E: ::fidl_next::Encoder + ?Sized,
465 {
466 #[inline]
467 fn encode(
468 self,
469 encoder: &mut ___E,
470 out: &mut ::core::mem::MaybeUninit<crate::wire::DestroyedPayload<'static>>,
471 _: (),
472 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
473 ::fidl_next::munge!(let crate::wire::DestroyedPayload { table } = out);
474
475 let max_ord = self.__max_ordinal();
476
477 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
478 ::fidl_next::Wire::zero_padding(&mut out);
479
480 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
481 ::fidl_next::wire::Envelope,
482 >(encoder, max_ord);
483
484 for i in 1..=max_ord {
485 match i {
486 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
487 }
488 unsafe {
489 preallocated.write_next(out.assume_init_ref());
490 }
491 }
492
493 ::fidl_next::wire::Table::encode_len(table, max_ord);
494
495 Ok(())
496 }
497 }
498
499 impl<'de> ::fidl_next::FromWire<crate::wire::DestroyedPayload<'de>> for DestroyedPayload {
500 #[inline]
501 fn from_wire(wire_: crate::wire::DestroyedPayload<'de>) -> Self {
502 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
503
504 Self {}
505 }
506 }
507
508 impl<'de> ::fidl_next::FromWireRef<crate::wire::DestroyedPayload<'de>> for DestroyedPayload {
509 #[inline]
510 fn from_wire_ref(wire: &crate::wire::DestroyedPayload<'de>) -> Self {
511 Self {}
512 }
513 }
514
515 #[doc = " Payload for Discovered events.\n"]
516 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
517 pub struct DiscoveredPayload {}
518
519 impl DiscoveredPayload {
520 fn __max_ordinal(&self) -> usize {
521 0
522 }
523 }
524
525 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DiscoveredPayload<'static>, ___E>
526 for DiscoveredPayload
527 where
528 ___E: ::fidl_next::Encoder + ?Sized,
529 {
530 #[inline]
531 fn encode(
532 mut self,
533 encoder: &mut ___E,
534 out: &mut ::core::mem::MaybeUninit<crate::wire::DiscoveredPayload<'static>>,
535 _: (),
536 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
537 ::fidl_next::munge!(let crate::wire::DiscoveredPayload { table } = out);
538
539 let max_ord = self.__max_ordinal();
540
541 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
542 ::fidl_next::Wire::zero_padding(&mut out);
543
544 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
545 ::fidl_next::wire::Envelope,
546 >(encoder, max_ord);
547
548 for i in 1..=max_ord {
549 match i {
550 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
551 }
552 unsafe {
553 preallocated.write_next(out.assume_init_ref());
554 }
555 }
556
557 ::fidl_next::wire::Table::encode_len(table, max_ord);
558
559 Ok(())
560 }
561 }
562
563 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::DiscoveredPayload<'static>, ___E>
564 for &'a DiscoveredPayload
565 where
566 ___E: ::fidl_next::Encoder + ?Sized,
567 {
568 #[inline]
569 fn encode(
570 self,
571 encoder: &mut ___E,
572 out: &mut ::core::mem::MaybeUninit<crate::wire::DiscoveredPayload<'static>>,
573 _: (),
574 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
575 ::fidl_next::munge!(let crate::wire::DiscoveredPayload { table } = out);
576
577 let max_ord = self.__max_ordinal();
578
579 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
580 ::fidl_next::Wire::zero_padding(&mut out);
581
582 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
583 ::fidl_next::wire::Envelope,
584 >(encoder, max_ord);
585
586 for i in 1..=max_ord {
587 match i {
588 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
589 }
590 unsafe {
591 preallocated.write_next(out.assume_init_ref());
592 }
593 }
594
595 ::fidl_next::wire::Table::encode_len(table, max_ord);
596
597 Ok(())
598 }
599 }
600
601 impl<'de> ::fidl_next::FromWire<crate::wire::DiscoveredPayload<'de>> for DiscoveredPayload {
602 #[inline]
603 fn from_wire(wire_: crate::wire::DiscoveredPayload<'de>) -> Self {
604 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
605
606 Self {}
607 }
608 }
609
610 impl<'de> ::fidl_next::FromWireRef<crate::wire::DiscoveredPayload<'de>> for DiscoveredPayload {
611 #[inline]
612 fn from_wire_ref(wire: &crate::wire::DiscoveredPayload<'de>) -> Self {
613 Self {}
614 }
615 }
616
617 #[doc = " Payload for Purged events.\n"]
618 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
619 pub struct PurgedPayload {}
620
621 impl PurgedPayload {
622 fn __max_ordinal(&self) -> usize {
623 0
624 }
625 }
626
627 unsafe impl<___E> ::fidl_next::Encode<crate::wire::PurgedPayload<'static>, ___E> for PurgedPayload
628 where
629 ___E: ::fidl_next::Encoder + ?Sized,
630 {
631 #[inline]
632 fn encode(
633 mut self,
634 encoder: &mut ___E,
635 out: &mut ::core::mem::MaybeUninit<crate::wire::PurgedPayload<'static>>,
636 _: (),
637 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
638 ::fidl_next::munge!(let crate::wire::PurgedPayload { table } = out);
639
640 let max_ord = self.__max_ordinal();
641
642 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
643 ::fidl_next::Wire::zero_padding(&mut out);
644
645 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
646 ::fidl_next::wire::Envelope,
647 >(encoder, max_ord);
648
649 for i in 1..=max_ord {
650 match i {
651 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
652 }
653 unsafe {
654 preallocated.write_next(out.assume_init_ref());
655 }
656 }
657
658 ::fidl_next::wire::Table::encode_len(table, max_ord);
659
660 Ok(())
661 }
662 }
663
664 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::PurgedPayload<'static>, ___E>
665 for &'a PurgedPayload
666 where
667 ___E: ::fidl_next::Encoder + ?Sized,
668 {
669 #[inline]
670 fn encode(
671 self,
672 encoder: &mut ___E,
673 out: &mut ::core::mem::MaybeUninit<crate::wire::PurgedPayload<'static>>,
674 _: (),
675 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
676 ::fidl_next::munge!(let crate::wire::PurgedPayload { table } = out);
677
678 let max_ord = self.__max_ordinal();
679
680 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
681 ::fidl_next::Wire::zero_padding(&mut out);
682
683 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
684 ::fidl_next::wire::Envelope,
685 >(encoder, max_ord);
686
687 for i in 1..=max_ord {
688 match i {
689 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
690 }
691 unsafe {
692 preallocated.write_next(out.assume_init_ref());
693 }
694 }
695
696 ::fidl_next::wire::Table::encode_len(table, max_ord);
697
698 Ok(())
699 }
700 }
701
702 impl<'de> ::fidl_next::FromWire<crate::wire::PurgedPayload<'de>> for PurgedPayload {
703 #[inline]
704 fn from_wire(wire_: crate::wire::PurgedPayload<'de>) -> Self {
705 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
706
707 Self {}
708 }
709 }
710
711 impl<'de> ::fidl_next::FromWireRef<crate::wire::PurgedPayload<'de>> for PurgedPayload {
712 #[inline]
713 fn from_wire_ref(wire: &crate::wire::PurgedPayload<'de>) -> Self {
714 Self {}
715 }
716 }
717
718 #[doc = " Payload for Resolved events.\n"]
719 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
720 pub struct ResolvedPayload {}
721
722 impl ResolvedPayload {
723 fn __max_ordinal(&self) -> usize {
724 0
725 }
726 }
727
728 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ResolvedPayload<'static>, ___E>
729 for ResolvedPayload
730 where
731 ___E: ::fidl_next::Encoder + ?Sized,
732 {
733 #[inline]
734 fn encode(
735 mut self,
736 encoder: &mut ___E,
737 out: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedPayload<'static>>,
738 _: (),
739 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
740 ::fidl_next::munge!(let crate::wire::ResolvedPayload { table } = out);
741
742 let max_ord = self.__max_ordinal();
743
744 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
745 ::fidl_next::Wire::zero_padding(&mut out);
746
747 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
748 ::fidl_next::wire::Envelope,
749 >(encoder, max_ord);
750
751 for i in 1..=max_ord {
752 match i {
753 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
754 }
755 unsafe {
756 preallocated.write_next(out.assume_init_ref());
757 }
758 }
759
760 ::fidl_next::wire::Table::encode_len(table, max_ord);
761
762 Ok(())
763 }
764 }
765
766 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ResolvedPayload<'static>, ___E>
767 for &'a ResolvedPayload
768 where
769 ___E: ::fidl_next::Encoder + ?Sized,
770 {
771 #[inline]
772 fn encode(
773 self,
774 encoder: &mut ___E,
775 out: &mut ::core::mem::MaybeUninit<crate::wire::ResolvedPayload<'static>>,
776 _: (),
777 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
778 ::fidl_next::munge!(let crate::wire::ResolvedPayload { table } = out);
779
780 let max_ord = self.__max_ordinal();
781
782 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
783 ::fidl_next::Wire::zero_padding(&mut out);
784
785 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
786 ::fidl_next::wire::Envelope,
787 >(encoder, max_ord);
788
789 for i in 1..=max_ord {
790 match i {
791 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
792 }
793 unsafe {
794 preallocated.write_next(out.assume_init_ref());
795 }
796 }
797
798 ::fidl_next::wire::Table::encode_len(table, max_ord);
799
800 Ok(())
801 }
802 }
803
804 impl<'de> ::fidl_next::FromWire<crate::wire::ResolvedPayload<'de>> for ResolvedPayload {
805 #[inline]
806 fn from_wire(wire_: crate::wire::ResolvedPayload<'de>) -> Self {
807 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
808
809 Self {}
810 }
811 }
812
813 impl<'de> ::fidl_next::FromWireRef<crate::wire::ResolvedPayload<'de>> for ResolvedPayload {
814 #[inline]
815 fn from_wire_ref(wire: &crate::wire::ResolvedPayload<'de>) -> Self {
816 Self {}
817 }
818 }
819
820 #[doc = " Payload for Started events.\n"]
821 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
822 pub struct StartedPayload {}
823
824 impl StartedPayload {
825 fn __max_ordinal(&self) -> usize {
826 0
827 }
828 }
829
830 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartedPayload<'static>, ___E> for StartedPayload
831 where
832 ___E: ::fidl_next::Encoder + ?Sized,
833 {
834 #[inline]
835 fn encode(
836 mut self,
837 encoder: &mut ___E,
838 out: &mut ::core::mem::MaybeUninit<crate::wire::StartedPayload<'static>>,
839 _: (),
840 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
841 ::fidl_next::munge!(let crate::wire::StartedPayload { table } = out);
842
843 let max_ord = self.__max_ordinal();
844
845 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
846 ::fidl_next::Wire::zero_padding(&mut out);
847
848 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
849 ::fidl_next::wire::Envelope,
850 >(encoder, max_ord);
851
852 for i in 1..=max_ord {
853 match i {
854 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
855 }
856 unsafe {
857 preallocated.write_next(out.assume_init_ref());
858 }
859 }
860
861 ::fidl_next::wire::Table::encode_len(table, max_ord);
862
863 Ok(())
864 }
865 }
866
867 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StartedPayload<'static>, ___E>
868 for &'a StartedPayload
869 where
870 ___E: ::fidl_next::Encoder + ?Sized,
871 {
872 #[inline]
873 fn encode(
874 self,
875 encoder: &mut ___E,
876 out: &mut ::core::mem::MaybeUninit<crate::wire::StartedPayload<'static>>,
877 _: (),
878 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
879 ::fidl_next::munge!(let crate::wire::StartedPayload { table } = out);
880
881 let max_ord = self.__max_ordinal();
882
883 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
884 ::fidl_next::Wire::zero_padding(&mut out);
885
886 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
887 ::fidl_next::wire::Envelope,
888 >(encoder, max_ord);
889
890 for i in 1..=max_ord {
891 match i {
892 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
893 }
894 unsafe {
895 preallocated.write_next(out.assume_init_ref());
896 }
897 }
898
899 ::fidl_next::wire::Table::encode_len(table, max_ord);
900
901 Ok(())
902 }
903 }
904
905 impl<'de> ::fidl_next::FromWire<crate::wire::StartedPayload<'de>> for StartedPayload {
906 #[inline]
907 fn from_wire(wire_: crate::wire::StartedPayload<'de>) -> Self {
908 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
909
910 Self {}
911 }
912 }
913
914 impl<'de> ::fidl_next::FromWireRef<crate::wire::StartedPayload<'de>> for StartedPayload {
915 #[inline]
916 fn from_wire_ref(wire: &crate::wire::StartedPayload<'de>) -> Self {
917 Self {}
918 }
919 }
920
921 #[doc = " Payload for Unresolved events.\n"]
922 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
923 pub struct UnresolvedPayload {}
924
925 impl UnresolvedPayload {
926 fn __max_ordinal(&self) -> usize {
927 0
928 }
929 }
930
931 unsafe impl<___E> ::fidl_next::Encode<crate::wire::UnresolvedPayload<'static>, ___E>
932 for UnresolvedPayload
933 where
934 ___E: ::fidl_next::Encoder + ?Sized,
935 {
936 #[inline]
937 fn encode(
938 mut self,
939 encoder: &mut ___E,
940 out: &mut ::core::mem::MaybeUninit<crate::wire::UnresolvedPayload<'static>>,
941 _: (),
942 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
943 ::fidl_next::munge!(let crate::wire::UnresolvedPayload { table } = out);
944
945 let max_ord = self.__max_ordinal();
946
947 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
948 ::fidl_next::Wire::zero_padding(&mut out);
949
950 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
951 ::fidl_next::wire::Envelope,
952 >(encoder, max_ord);
953
954 for i in 1..=max_ord {
955 match i {
956 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
957 }
958 unsafe {
959 preallocated.write_next(out.assume_init_ref());
960 }
961 }
962
963 ::fidl_next::wire::Table::encode_len(table, max_ord);
964
965 Ok(())
966 }
967 }
968
969 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::UnresolvedPayload<'static>, ___E>
970 for &'a UnresolvedPayload
971 where
972 ___E: ::fidl_next::Encoder + ?Sized,
973 {
974 #[inline]
975 fn encode(
976 self,
977 encoder: &mut ___E,
978 out: &mut ::core::mem::MaybeUninit<crate::wire::UnresolvedPayload<'static>>,
979 _: (),
980 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
981 ::fidl_next::munge!(let crate::wire::UnresolvedPayload { table } = out);
982
983 let max_ord = self.__max_ordinal();
984
985 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
986 ::fidl_next::Wire::zero_padding(&mut out);
987
988 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
989 ::fidl_next::wire::Envelope,
990 >(encoder, max_ord);
991
992 for i in 1..=max_ord {
993 match i {
994 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
995 }
996 unsafe {
997 preallocated.write_next(out.assume_init_ref());
998 }
999 }
1000
1001 ::fidl_next::wire::Table::encode_len(table, max_ord);
1002
1003 Ok(())
1004 }
1005 }
1006
1007 impl<'de> ::fidl_next::FromWire<crate::wire::UnresolvedPayload<'de>> for UnresolvedPayload {
1008 #[inline]
1009 fn from_wire(wire_: crate::wire::UnresolvedPayload<'de>) -> Self {
1010 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1011
1012 Self {}
1013 }
1014 }
1015
1016 impl<'de> ::fidl_next::FromWireRef<crate::wire::UnresolvedPayload<'de>> for UnresolvedPayload {
1017 #[inline]
1018 fn from_wire_ref(wire: &crate::wire::UnresolvedPayload<'de>) -> Self {
1019 Self {}
1020 }
1021 }
1022
1023 #[doc = " These EventTypes are used for the EventStream protocol.\n They are FIDL versions of the EventType enum in hooks.rs and have\n the same meaning.\n"]
1024 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1025 #[repr(u32)]
1026 pub enum EventType {
1027 CapabilityRequested = 1,
1028 Discovered = 3,
1029 Destroyed = 4,
1030 Resolved = 5,
1031 Started = 6,
1032 Stopped = 7,
1033 DebugStarted = 8,
1034 Unresolved = 9,
1035 }
1036 impl ::core::convert::TryFrom<u32> for EventType {
1037 type Error = ::fidl_next::UnknownStrictEnumMemberError;
1038 fn try_from(
1039 value: u32,
1040 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
1041 match value {
1042 1 => Ok(Self::CapabilityRequested),
1043 3 => Ok(Self::Discovered),
1044 4 => Ok(Self::Destroyed),
1045 5 => Ok(Self::Resolved),
1046 6 => Ok(Self::Started),
1047 7 => Ok(Self::Stopped),
1048 8 => Ok(Self::DebugStarted),
1049 9 => Ok(Self::Unresolved),
1050
1051 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
1052 }
1053 }
1054 }
1055
1056 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventType, ___E> for EventType
1057 where
1058 ___E: ?Sized,
1059 {
1060 #[inline]
1061 fn encode(
1062 self,
1063 encoder: &mut ___E,
1064 out: &mut ::core::mem::MaybeUninit<crate::wire::EventType>,
1065 _: (),
1066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1067 ::fidl_next::Encode::encode(&self, encoder, out, ())
1068 }
1069 }
1070
1071 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventType, ___E> for &'a EventType
1072 where
1073 ___E: ?Sized,
1074 {
1075 #[inline]
1076 fn encode(
1077 self,
1078 encoder: &mut ___E,
1079 out: &mut ::core::mem::MaybeUninit<crate::wire::EventType>,
1080 _: (),
1081 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1082 ::fidl_next::munge!(let crate::wire::EventType { value } = out);
1083 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
1084 EventType::CapabilityRequested => 1,
1085
1086 EventType::Discovered => 3,
1087
1088 EventType::Destroyed => 4,
1089
1090 EventType::Resolved => 5,
1091
1092 EventType::Started => 6,
1093
1094 EventType::Stopped => 7,
1095
1096 EventType::DebugStarted => 8,
1097
1098 EventType::Unresolved => 9,
1099 }));
1100
1101 Ok(())
1102 }
1103 }
1104
1105 impl ::core::convert::From<crate::wire::EventType> for EventType {
1106 fn from(wire: crate::wire::EventType) -> Self {
1107 match u32::from(wire.value) {
1108 1 => Self::CapabilityRequested,
1109
1110 3 => Self::Discovered,
1111
1112 4 => Self::Destroyed,
1113
1114 5 => Self::Resolved,
1115
1116 6 => Self::Started,
1117
1118 7 => Self::Stopped,
1119
1120 8 => Self::DebugStarted,
1121
1122 9 => Self::Unresolved,
1123
1124 _ => unsafe { ::core::hint::unreachable_unchecked() },
1125 }
1126 }
1127 }
1128
1129 impl ::fidl_next::FromWire<crate::wire::EventType> for EventType {
1130 #[inline]
1131 fn from_wire(wire: crate::wire::EventType) -> Self {
1132 Self::from(wire)
1133 }
1134 }
1135
1136 impl ::fidl_next::FromWireRef<crate::wire::EventType> for EventType {
1137 #[inline]
1138 fn from_wire_ref(wire: &crate::wire::EventType) -> Self {
1139 Self::from(*wire)
1140 }
1141 }
1142
1143 #[doc = " Payload for Stopped events.\n"]
1144 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1145 pub struct StoppedPayload {
1146 pub status: ::core::option::Option<i32>,
1147
1148 pub exit_code: ::core::option::Option<i64>,
1149 }
1150
1151 impl StoppedPayload {
1152 fn __max_ordinal(&self) -> usize {
1153 if self.exit_code.is_some() {
1154 return 2;
1155 }
1156
1157 if self.status.is_some() {
1158 return 1;
1159 }
1160
1161 0
1162 }
1163 }
1164
1165 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E> for StoppedPayload
1166 where
1167 ___E: ::fidl_next::Encoder + ?Sized,
1168 {
1169 #[inline]
1170 fn encode(
1171 mut self,
1172 encoder: &mut ___E,
1173 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1174 _: (),
1175 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1176 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1177
1178 let max_ord = self.__max_ordinal();
1179
1180 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1181 ::fidl_next::Wire::zero_padding(&mut out);
1182
1183 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1184 ::fidl_next::wire::Envelope,
1185 >(encoder, max_ord);
1186
1187 for i in 1..=max_ord {
1188 match i {
1189 2 => {
1190 if let Some(value) = self.exit_code.take() {
1191 ::fidl_next::wire::Envelope::encode_value::<
1192 ::fidl_next::wire::Int64,
1193 ___E,
1194 >(
1195 value, preallocated.encoder, &mut out, ()
1196 )?;
1197 } else {
1198 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1199 }
1200 }
1201
1202 1 => {
1203 if let Some(value) = self.status.take() {
1204 ::fidl_next::wire::Envelope::encode_value::<
1205 ::fidl_next::wire::Int32,
1206 ___E,
1207 >(
1208 value, preallocated.encoder, &mut out, ()
1209 )?;
1210 } else {
1211 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1212 }
1213 }
1214
1215 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1216 }
1217 unsafe {
1218 preallocated.write_next(out.assume_init_ref());
1219 }
1220 }
1221
1222 ::fidl_next::wire::Table::encode_len(table, max_ord);
1223
1224 Ok(())
1225 }
1226 }
1227
1228 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>
1229 for &'a StoppedPayload
1230 where
1231 ___E: ::fidl_next::Encoder + ?Sized,
1232 {
1233 #[inline]
1234 fn encode(
1235 self,
1236 encoder: &mut ___E,
1237 out: &mut ::core::mem::MaybeUninit<crate::wire::StoppedPayload<'static>>,
1238 _: (),
1239 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1240 ::fidl_next::munge!(let crate::wire::StoppedPayload { table } = out);
1241
1242 let max_ord = self.__max_ordinal();
1243
1244 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1245 ::fidl_next::Wire::zero_padding(&mut out);
1246
1247 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1248 ::fidl_next::wire::Envelope,
1249 >(encoder, max_ord);
1250
1251 for i in 1..=max_ord {
1252 match i {
1253 2 => {
1254 if let Some(value) = &self.exit_code {
1255 ::fidl_next::wire::Envelope::encode_value::<
1256 ::fidl_next::wire::Int64,
1257 ___E,
1258 >(
1259 value, preallocated.encoder, &mut out, ()
1260 )?;
1261 } else {
1262 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1263 }
1264 }
1265
1266 1 => {
1267 if let Some(value) = &self.status {
1268 ::fidl_next::wire::Envelope::encode_value::<
1269 ::fidl_next::wire::Int32,
1270 ___E,
1271 >(
1272 value, preallocated.encoder, &mut out, ()
1273 )?;
1274 } else {
1275 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1276 }
1277 }
1278
1279 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1280 }
1281 unsafe {
1282 preallocated.write_next(out.assume_init_ref());
1283 }
1284 }
1285
1286 ::fidl_next::wire::Table::encode_len(table, max_ord);
1287
1288 Ok(())
1289 }
1290 }
1291
1292 impl<'de> ::fidl_next::FromWire<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1293 #[inline]
1294 fn from_wire(wire_: crate::wire::StoppedPayload<'de>) -> Self {
1295 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1296
1297 let status = wire_.table.get(1);
1298
1299 let exit_code = wire_.table.get(2);
1300
1301 Self {
1302 status: status.map(|envelope| {
1303 ::fidl_next::FromWire::from_wire(unsafe {
1304 envelope.read_unchecked::<::fidl_next::wire::Int32>()
1305 })
1306 }),
1307
1308 exit_code: exit_code.map(|envelope| {
1309 ::fidl_next::FromWire::from_wire(unsafe {
1310 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1311 })
1312 }),
1313 }
1314 }
1315 }
1316
1317 impl<'de> ::fidl_next::FromWireRef<crate::wire::StoppedPayload<'de>> for StoppedPayload {
1318 #[inline]
1319 fn from_wire_ref(wire: &crate::wire::StoppedPayload<'de>) -> Self {
1320 Self {
1321 status: wire.table.get(1).map(|envelope| {
1322 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1323 envelope.deref_unchecked::<::fidl_next::wire::Int32>()
1324 })
1325 }),
1326
1327 exit_code: wire.table.get(2).map(|envelope| {
1328 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1329 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1330 })
1331 }),
1332 }
1333 }
1334 }
1335
1336 #[doc = " A head providing metadata about a target component instance.\n"]
1337 #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1338 pub struct EventHeader {
1339 pub event_type: ::core::option::Option<crate::natural::EventType>,
1340
1341 pub moniker: ::core::option::Option<::std::string::String>,
1342
1343 pub component_url: ::core::option::Option<::std::string::String>,
1344
1345 pub timestamp: ::core::option::Option<i64>,
1346 }
1347
1348 impl EventHeader {
1349 fn __max_ordinal(&self) -> usize {
1350 if self.timestamp.is_some() {
1351 return 4;
1352 }
1353
1354 if self.component_url.is_some() {
1355 return 3;
1356 }
1357
1358 if self.moniker.is_some() {
1359 return 2;
1360 }
1361
1362 if self.event_type.is_some() {
1363 return 1;
1364 }
1365
1366 0
1367 }
1368 }
1369
1370 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E> for EventHeader
1371 where
1372 ___E: ::fidl_next::Encoder + ?Sized,
1373 {
1374 #[inline]
1375 fn encode(
1376 mut self,
1377 encoder: &mut ___E,
1378 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1379 _: (),
1380 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1381 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1382
1383 let max_ord = self.__max_ordinal();
1384
1385 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1386 ::fidl_next::Wire::zero_padding(&mut out);
1387
1388 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1389 ::fidl_next::wire::Envelope,
1390 >(encoder, max_ord);
1391
1392 for i in 1..=max_ord {
1393 match i {
1394 4 => {
1395 if let Some(value) = self.timestamp.take() {
1396 ::fidl_next::wire::Envelope::encode_value::<
1397 ::fidl_next::wire::Int64,
1398 ___E,
1399 >(
1400 value, preallocated.encoder, &mut out, ()
1401 )?;
1402 } else {
1403 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1404 }
1405 }
1406
1407 3 => {
1408 if let Some(value) = self.component_url.take() {
1409 ::fidl_next::wire::Envelope::encode_value::<
1410 ::fidl_next::wire::String<'static>,
1411 ___E,
1412 >(
1413 value, preallocated.encoder, &mut out, 4096
1414 )?;
1415 } else {
1416 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1417 }
1418 }
1419
1420 2 => {
1421 if let Some(value) = self.moniker.take() {
1422 ::fidl_next::wire::Envelope::encode_value::<
1423 ::fidl_next::wire::String<'static>,
1424 ___E,
1425 >(
1426 value, preallocated.encoder, &mut out, 4096
1427 )?;
1428 } else {
1429 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1430 }
1431 }
1432
1433 1 => {
1434 if let Some(value) = self.event_type.take() {
1435 ::fidl_next::wire::Envelope::encode_value::<
1436 crate::wire::EventType,
1437 ___E,
1438 >(
1439 value, preallocated.encoder, &mut out, ()
1440 )?;
1441 } else {
1442 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1443 }
1444 }
1445
1446 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1447 }
1448 unsafe {
1449 preallocated.write_next(out.assume_init_ref());
1450 }
1451 }
1452
1453 ::fidl_next::wire::Table::encode_len(table, max_ord);
1454
1455 Ok(())
1456 }
1457 }
1458
1459 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::EventHeader<'static>, ___E>
1460 for &'a EventHeader
1461 where
1462 ___E: ::fidl_next::Encoder + ?Sized,
1463 {
1464 #[inline]
1465 fn encode(
1466 self,
1467 encoder: &mut ___E,
1468 out: &mut ::core::mem::MaybeUninit<crate::wire::EventHeader<'static>>,
1469 _: (),
1470 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1471 ::fidl_next::munge!(let crate::wire::EventHeader { table } = out);
1472
1473 let max_ord = self.__max_ordinal();
1474
1475 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1476 ::fidl_next::Wire::zero_padding(&mut out);
1477
1478 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1479 ::fidl_next::wire::Envelope,
1480 >(encoder, max_ord);
1481
1482 for i in 1..=max_ord {
1483 match i {
1484 4 => {
1485 if let Some(value) = &self.timestamp {
1486 ::fidl_next::wire::Envelope::encode_value::<
1487 ::fidl_next::wire::Int64,
1488 ___E,
1489 >(
1490 value, preallocated.encoder, &mut out, ()
1491 )?;
1492 } else {
1493 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1494 }
1495 }
1496
1497 3 => {
1498 if let Some(value) = &self.component_url {
1499 ::fidl_next::wire::Envelope::encode_value::<
1500 ::fidl_next::wire::String<'static>,
1501 ___E,
1502 >(
1503 value, preallocated.encoder, &mut out, 4096
1504 )?;
1505 } else {
1506 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1507 }
1508 }
1509
1510 2 => {
1511 if let Some(value) = &self.moniker {
1512 ::fidl_next::wire::Envelope::encode_value::<
1513 ::fidl_next::wire::String<'static>,
1514 ___E,
1515 >(
1516 value, preallocated.encoder, &mut out, 4096
1517 )?;
1518 } else {
1519 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1520 }
1521 }
1522
1523 1 => {
1524 if let Some(value) = &self.event_type {
1525 ::fidl_next::wire::Envelope::encode_value::<
1526 crate::wire::EventType,
1527 ___E,
1528 >(
1529 value, preallocated.encoder, &mut out, ()
1530 )?;
1531 } else {
1532 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1533 }
1534 }
1535
1536 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1537 }
1538 unsafe {
1539 preallocated.write_next(out.assume_init_ref());
1540 }
1541 }
1542
1543 ::fidl_next::wire::Table::encode_len(table, max_ord);
1544
1545 Ok(())
1546 }
1547 }
1548
1549 impl<'de> ::fidl_next::FromWire<crate::wire::EventHeader<'de>> for EventHeader {
1550 #[inline]
1551 fn from_wire(wire_: crate::wire::EventHeader<'de>) -> Self {
1552 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1553
1554 let event_type = wire_.table.get(1);
1555
1556 let moniker = wire_.table.get(2);
1557
1558 let component_url = wire_.table.get(3);
1559
1560 let timestamp = wire_.table.get(4);
1561
1562 Self {
1563 event_type: event_type.map(|envelope| {
1564 ::fidl_next::FromWire::from_wire(unsafe {
1565 envelope.read_unchecked::<crate::wire::EventType>()
1566 })
1567 }),
1568
1569 moniker: moniker.map(|envelope| {
1570 ::fidl_next::FromWire::from_wire(unsafe {
1571 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1572 })
1573 }),
1574
1575 component_url: component_url.map(|envelope| {
1576 ::fidl_next::FromWire::from_wire(unsafe {
1577 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
1578 })
1579 }),
1580
1581 timestamp: timestamp.map(|envelope| {
1582 ::fidl_next::FromWire::from_wire(unsafe {
1583 envelope.read_unchecked::<::fidl_next::wire::Int64>()
1584 })
1585 }),
1586 }
1587 }
1588 }
1589
1590 impl<'de> ::fidl_next::FromWireRef<crate::wire::EventHeader<'de>> for EventHeader {
1591 #[inline]
1592 fn from_wire_ref(wire: &crate::wire::EventHeader<'de>) -> Self {
1593 Self {
1594 event_type: wire.table.get(1).map(|envelope| {
1595 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1596 envelope.deref_unchecked::<crate::wire::EventType>()
1597 })
1598 }),
1599
1600 moniker: wire.table.get(2).map(|envelope| {
1601 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1602 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1603 })
1604 }),
1605
1606 component_url: wire.table.get(3).map(|envelope| {
1607 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1608 envelope.deref_unchecked::<::fidl_next::wire::String<'de>>()
1609 })
1610 }),
1611
1612 timestamp: wire.table.get(4).map(|envelope| {
1613 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
1614 envelope.deref_unchecked::<::fidl_next::wire::Int64>()
1615 })
1616 }),
1617 }
1618 }
1619 }
1620
1621 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1622 pub struct ExecutionControllerOnStopRequest {
1623 pub stopped_payload: crate::natural::StoppedPayload,
1624 }
1625
1626 unsafe impl<___E>
1627 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1628 for ExecutionControllerOnStopRequest
1629 where
1630 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1631 ___E: ::fidl_next::Encoder,
1632 {
1633 #[inline]
1634 fn encode(
1635 self,
1636 encoder_: &mut ___E,
1637 out_: &mut ::core::mem::MaybeUninit<
1638 crate::wire::ExecutionControllerOnStopRequest<'static>,
1639 >,
1640 _: (),
1641 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1642 ::fidl_next::munge! {
1643 let crate::wire::ExecutionControllerOnStopRequest {
1644 stopped_payload,
1645
1646 } = out_;
1647 }
1648
1649 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
1650
1651 let mut _field =
1652 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1653
1654 Ok(())
1655 }
1656 }
1657
1658 unsafe impl<'a, ___E>
1659 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
1660 for &'a ExecutionControllerOnStopRequest
1661 where
1662 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1663 ___E: ::fidl_next::Encoder,
1664 {
1665 #[inline]
1666 fn encode(
1667 self,
1668 encoder_: &mut ___E,
1669 out_: &mut ::core::mem::MaybeUninit<
1670 crate::wire::ExecutionControllerOnStopRequest<'static>,
1671 >,
1672 _: (),
1673 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1674 ::fidl_next::munge! {
1675 let crate::wire::ExecutionControllerOnStopRequest {
1676 stopped_payload,
1677
1678 } = out_;
1679 }
1680
1681 ::fidl_next::Encode::encode(&self.stopped_payload, encoder_, stopped_payload, ())?;
1682
1683 let mut _field =
1684 unsafe { ::fidl_next::Slot::new_unchecked(stopped_payload.as_mut_ptr()) };
1685
1686 Ok(())
1687 }
1688 }
1689
1690 unsafe impl<___E>
1691 ::fidl_next::EncodeOption<
1692 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1693 ___E,
1694 > for ExecutionControllerOnStopRequest
1695 where
1696 ___E: ::fidl_next::Encoder + ?Sized,
1697 ExecutionControllerOnStopRequest:
1698 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1699 {
1700 #[inline]
1701 fn encode_option(
1702 this: ::core::option::Option<Self>,
1703 encoder: &mut ___E,
1704 out: &mut ::core::mem::MaybeUninit<
1705 ::fidl_next::wire::Box<
1706 'static,
1707 crate::wire::ExecutionControllerOnStopRequest<'static>,
1708 >,
1709 >,
1710 _: (),
1711 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1712 if let Some(inner) = this {
1713 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1714 ::fidl_next::wire::Box::encode_present(out);
1715 } else {
1716 ::fidl_next::wire::Box::encode_absent(out);
1717 }
1718
1719 Ok(())
1720 }
1721 }
1722
1723 unsafe impl<'a, ___E>
1724 ::fidl_next::EncodeOption<
1725 ::fidl_next::wire::Box<'static, crate::wire::ExecutionControllerOnStopRequest<'static>>,
1726 ___E,
1727 > for &'a ExecutionControllerOnStopRequest
1728 where
1729 ___E: ::fidl_next::Encoder + ?Sized,
1730 &'a ExecutionControllerOnStopRequest:
1731 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>,
1732 {
1733 #[inline]
1734 fn encode_option(
1735 this: ::core::option::Option<Self>,
1736 encoder: &mut ___E,
1737 out: &mut ::core::mem::MaybeUninit<
1738 ::fidl_next::wire::Box<
1739 'static,
1740 crate::wire::ExecutionControllerOnStopRequest<'static>,
1741 >,
1742 >,
1743 _: (),
1744 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1745 if let Some(inner) = this {
1746 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1747 ::fidl_next::wire::Box::encode_present(out);
1748 } else {
1749 ::fidl_next::wire::Box::encode_absent(out);
1750 }
1751
1752 Ok(())
1753 }
1754 }
1755
1756 impl<'de> ::fidl_next::FromWire<crate::wire::ExecutionControllerOnStopRequest<'de>>
1757 for ExecutionControllerOnStopRequest
1758 {
1759 #[inline]
1760 fn from_wire(wire: crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1761 Self { stopped_payload: ::fidl_next::FromWire::from_wire(wire.stopped_payload) }
1762 }
1763 }
1764
1765 impl<'de> ::fidl_next::FromWireRef<crate::wire::ExecutionControllerOnStopRequest<'de>>
1766 for ExecutionControllerOnStopRequest
1767 {
1768 #[inline]
1769 fn from_wire_ref(wire: &crate::wire::ExecutionControllerOnStopRequest<'de>) -> Self {
1770 Self { stopped_payload: ::fidl_next::FromWireRef::from_wire_ref(&wire.stopped_payload) }
1771 }
1772 }
1773
1774 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1775 pub struct IntrospectorGetMonikerResponse {
1776 pub moniker: ::std::string::String,
1777 }
1778
1779 unsafe impl<___E>
1780 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1781 for IntrospectorGetMonikerResponse
1782 where
1783 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1784 ___E: ::fidl_next::Encoder,
1785 {
1786 #[inline]
1787 fn encode(
1788 self,
1789 encoder_: &mut ___E,
1790 out_: &mut ::core::mem::MaybeUninit<
1791 crate::wire::IntrospectorGetMonikerResponse<'static>,
1792 >,
1793 _: (),
1794 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1795 ::fidl_next::munge! {
1796 let crate::wire::IntrospectorGetMonikerResponse {
1797 moniker,
1798
1799 } = out_;
1800 }
1801
1802 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
1803
1804 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1805 ::fidl_next::Constrained::validate(_field, 4096)?;
1806
1807 Ok(())
1808 }
1809 }
1810
1811 unsafe impl<'a, ___E>
1812 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
1813 for &'a IntrospectorGetMonikerResponse
1814 where
1815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1816 ___E: ::fidl_next::Encoder,
1817 {
1818 #[inline]
1819 fn encode(
1820 self,
1821 encoder_: &mut ___E,
1822 out_: &mut ::core::mem::MaybeUninit<
1823 crate::wire::IntrospectorGetMonikerResponse<'static>,
1824 >,
1825 _: (),
1826 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1827 ::fidl_next::munge! {
1828 let crate::wire::IntrospectorGetMonikerResponse {
1829 moniker,
1830
1831 } = out_;
1832 }
1833
1834 ::fidl_next::Encode::encode(&self.moniker, encoder_, moniker, 4096)?;
1835
1836 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(moniker.as_mut_ptr()) };
1837 ::fidl_next::Constrained::validate(_field, 4096)?;
1838
1839 Ok(())
1840 }
1841 }
1842
1843 unsafe impl<___E>
1844 ::fidl_next::EncodeOption<
1845 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1846 ___E,
1847 > for IntrospectorGetMonikerResponse
1848 where
1849 ___E: ::fidl_next::Encoder + ?Sized,
1850 IntrospectorGetMonikerResponse:
1851 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1852 {
1853 #[inline]
1854 fn encode_option(
1855 this: ::core::option::Option<Self>,
1856 encoder: &mut ___E,
1857 out: &mut ::core::mem::MaybeUninit<
1858 ::fidl_next::wire::Box<
1859 'static,
1860 crate::wire::IntrospectorGetMonikerResponse<'static>,
1861 >,
1862 >,
1863 _: (),
1864 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1865 if let Some(inner) = this {
1866 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1867 ::fidl_next::wire::Box::encode_present(out);
1868 } else {
1869 ::fidl_next::wire::Box::encode_absent(out);
1870 }
1871
1872 Ok(())
1873 }
1874 }
1875
1876 unsafe impl<'a, ___E>
1877 ::fidl_next::EncodeOption<
1878 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerResponse<'static>>,
1879 ___E,
1880 > for &'a IntrospectorGetMonikerResponse
1881 where
1882 ___E: ::fidl_next::Encoder + ?Sized,
1883 &'a IntrospectorGetMonikerResponse:
1884 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>,
1885 {
1886 #[inline]
1887 fn encode_option(
1888 this: ::core::option::Option<Self>,
1889 encoder: &mut ___E,
1890 out: &mut ::core::mem::MaybeUninit<
1891 ::fidl_next::wire::Box<
1892 'static,
1893 crate::wire::IntrospectorGetMonikerResponse<'static>,
1894 >,
1895 >,
1896 _: (),
1897 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1898 if let Some(inner) = this {
1899 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1900 ::fidl_next::wire::Box::encode_present(out);
1901 } else {
1902 ::fidl_next::wire::Box::encode_absent(out);
1903 }
1904
1905 Ok(())
1906 }
1907 }
1908
1909 impl<'de> ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerResponse<'de>>
1910 for IntrospectorGetMonikerResponse
1911 {
1912 #[inline]
1913 fn from_wire(wire: crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1914 Self { moniker: ::fidl_next::FromWire::from_wire(wire.moniker) }
1915 }
1916 }
1917
1918 impl<'de> ::fidl_next::FromWireRef<crate::wire::IntrospectorGetMonikerResponse<'de>>
1919 for IntrospectorGetMonikerResponse
1920 {
1921 #[inline]
1922 fn from_wire_ref(wire: &crate::wire::IntrospectorGetMonikerResponse<'de>) -> Self {
1923 Self { moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.moniker) }
1924 }
1925 }
1926
1927 #[doc = " Error returned from methods in [`Namespace`].\n"]
1928 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
1929 #[repr(u32)]
1930 pub enum NamespaceError {
1931 Shadow = 1,
1932 Duplicate = 2,
1933 Conversion = 3,
1934 BadEntry = 4,
1935 DictionaryRead = 5,
1936 UnknownOrdinal_(u32) = 6,
1937 }
1938 impl ::std::convert::From<u32> for NamespaceError {
1939 fn from(value: u32) -> Self {
1940 match value {
1941 1 => Self::Shadow,
1942 2 => Self::Duplicate,
1943 3 => Self::Conversion,
1944 4 => Self::BadEntry,
1945 5 => Self::DictionaryRead,
1946
1947 _ => Self::UnknownOrdinal_(value),
1948 }
1949 }
1950 }
1951
1952 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for NamespaceError
1953 where
1954 ___E: ?Sized,
1955 {
1956 #[inline]
1957 fn encode(
1958 self,
1959 encoder: &mut ___E,
1960 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
1961 _: (),
1962 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1963 ::fidl_next::Encode::encode(&self, encoder, out, ())
1964 }
1965 }
1966
1967 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::NamespaceError, ___E> for &'a NamespaceError
1968 where
1969 ___E: ?Sized,
1970 {
1971 #[inline]
1972 fn encode(
1973 self,
1974 encoder: &mut ___E,
1975 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceError>,
1976 _: (),
1977 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1978 ::fidl_next::munge!(let crate::wire::NamespaceError { value } = out);
1979 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
1980 NamespaceError::Shadow => 1,
1981
1982 NamespaceError::Duplicate => 2,
1983
1984 NamespaceError::Conversion => 3,
1985
1986 NamespaceError::BadEntry => 4,
1987
1988 NamespaceError::DictionaryRead => 5,
1989
1990 NamespaceError::UnknownOrdinal_(value) => value,
1991 }));
1992
1993 Ok(())
1994 }
1995 }
1996
1997 impl ::core::convert::From<crate::wire::NamespaceError> for NamespaceError {
1998 fn from(wire: crate::wire::NamespaceError) -> Self {
1999 match u32::from(wire.value) {
2000 1 => Self::Shadow,
2001
2002 2 => Self::Duplicate,
2003
2004 3 => Self::Conversion,
2005
2006 4 => Self::BadEntry,
2007
2008 5 => Self::DictionaryRead,
2009
2010 value => Self::UnknownOrdinal_(value),
2011 }
2012 }
2013 }
2014
2015 impl ::fidl_next::FromWire<crate::wire::NamespaceError> for NamespaceError {
2016 #[inline]
2017 fn from_wire(wire: crate::wire::NamespaceError) -> Self {
2018 Self::from(wire)
2019 }
2020 }
2021
2022 impl ::fidl_next::FromWireRef<crate::wire::NamespaceError> for NamespaceError {
2023 #[inline]
2024 fn from_wire_ref(wire: &crate::wire::NamespaceError) -> Self {
2025 Self::from(*wire)
2026 }
2027 }
2028
2029 pub type RealmOpenExposedDirResponse = ();
2030
2031 pub type RealmCreateChildResponse = ();
2032
2033 #[derive(Debug, Clone, PartialEq)]
2034 pub struct RealmDestroyChildRequest {
2035 pub child: ::fidl_next_common_fuchsia_component_decl::natural::ChildRef,
2036 }
2037
2038 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2039 for RealmDestroyChildRequest
2040 where
2041 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2042 ___E: ::fidl_next::Encoder,
2043 {
2044 #[inline]
2045 fn encode(
2046 self,
2047 encoder_: &mut ___E,
2048 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2049 _: (),
2050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2051 ::fidl_next::munge! {
2052 let crate::wire::RealmDestroyChildRequest {
2053 child,
2054
2055 } = out_;
2056 }
2057
2058 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2059
2060 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2061
2062 Ok(())
2063 }
2064 }
2065
2066 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
2067 for &'a RealmDestroyChildRequest
2068 where
2069 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2070 ___E: ::fidl_next::Encoder,
2071 {
2072 #[inline]
2073 fn encode(
2074 self,
2075 encoder_: &mut ___E,
2076 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
2077 _: (),
2078 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2079 ::fidl_next::munge! {
2080 let crate::wire::RealmDestroyChildRequest {
2081 child,
2082
2083 } = out_;
2084 }
2085
2086 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
2087
2088 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2089
2090 Ok(())
2091 }
2092 }
2093
2094 unsafe impl<___E>
2095 ::fidl_next::EncodeOption<
2096 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2097 ___E,
2098 > for RealmDestroyChildRequest
2099 where
2100 ___E: ::fidl_next::Encoder + ?Sized,
2101 RealmDestroyChildRequest:
2102 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2103 {
2104 #[inline]
2105 fn encode_option(
2106 this: ::core::option::Option<Self>,
2107 encoder: &mut ___E,
2108 out: &mut ::core::mem::MaybeUninit<
2109 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2110 >,
2111 _: (),
2112 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2113 if let Some(inner) = this {
2114 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2115 ::fidl_next::wire::Box::encode_present(out);
2116 } else {
2117 ::fidl_next::wire::Box::encode_absent(out);
2118 }
2119
2120 Ok(())
2121 }
2122 }
2123
2124 unsafe impl<'a, ___E>
2125 ::fidl_next::EncodeOption<
2126 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2127 ___E,
2128 > for &'a RealmDestroyChildRequest
2129 where
2130 ___E: ::fidl_next::Encoder + ?Sized,
2131 &'a RealmDestroyChildRequest:
2132 ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>,
2133 {
2134 #[inline]
2135 fn encode_option(
2136 this: ::core::option::Option<Self>,
2137 encoder: &mut ___E,
2138 out: &mut ::core::mem::MaybeUninit<
2139 ::fidl_next::wire::Box<'static, crate::wire::RealmDestroyChildRequest<'static>>,
2140 >,
2141 _: (),
2142 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2143 if let Some(inner) = this {
2144 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2145 ::fidl_next::wire::Box::encode_present(out);
2146 } else {
2147 ::fidl_next::wire::Box::encode_absent(out);
2148 }
2149
2150 Ok(())
2151 }
2152 }
2153
2154 impl<'de> ::fidl_next::FromWire<crate::wire::RealmDestroyChildRequest<'de>>
2155 for RealmDestroyChildRequest
2156 {
2157 #[inline]
2158 fn from_wire(wire: crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2159 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2160 }
2161 }
2162
2163 impl<'de> ::fidl_next::FromWireRef<crate::wire::RealmDestroyChildRequest<'de>>
2164 for RealmDestroyChildRequest
2165 {
2166 #[inline]
2167 fn from_wire_ref(wire: &crate::wire::RealmDestroyChildRequest<'de>) -> Self {
2168 Self { child: ::fidl_next::FromWireRef::from_wire_ref(&wire.child) }
2169 }
2170 }
2171
2172 pub type RealmDestroyChildResponse = ();
2173
2174 pub type RealmListChildrenResponse = ();
2175
2176 pub type RealmOpenControllerResponse = ();
2177
2178 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2179 #[repr(u32)]
2180 pub enum StatusError {
2181 Provider = 1,
2182 ResponseInvalid = 2,
2183 StatusUnknown = 3,
2184 Unsupported = 4,
2185 }
2186 impl ::core::convert::TryFrom<u32> for StatusError {
2187 type Error = ::fidl_next::UnknownStrictEnumMemberError;
2188 fn try_from(
2189 value: u32,
2190 ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
2191 match value {
2192 1 => Ok(Self::Provider),
2193 2 => Ok(Self::ResponseInvalid),
2194 3 => Ok(Self::StatusUnknown),
2195 4 => Ok(Self::Unsupported),
2196
2197 _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
2198 }
2199 }
2200 }
2201
2202 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for StatusError
2203 where
2204 ___E: ?Sized,
2205 {
2206 #[inline]
2207 fn encode(
2208 self,
2209 encoder: &mut ___E,
2210 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2211 _: (),
2212 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2213 ::fidl_next::Encode::encode(&self, encoder, out, ())
2214 }
2215 }
2216
2217 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StatusError, ___E> for &'a StatusError
2218 where
2219 ___E: ?Sized,
2220 {
2221 #[inline]
2222 fn encode(
2223 self,
2224 encoder: &mut ___E,
2225 out: &mut ::core::mem::MaybeUninit<crate::wire::StatusError>,
2226 _: (),
2227 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2228 ::fidl_next::munge!(let crate::wire::StatusError { value } = out);
2229 let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
2230 StatusError::Provider => 1,
2231
2232 StatusError::ResponseInvalid => 2,
2233
2234 StatusError::StatusUnknown => 3,
2235
2236 StatusError::Unsupported => 4,
2237 }));
2238
2239 Ok(())
2240 }
2241 }
2242
2243 impl ::core::convert::From<crate::wire::StatusError> for StatusError {
2244 fn from(wire: crate::wire::StatusError) -> Self {
2245 match u32::from(wire.value) {
2246 1 => Self::Provider,
2247
2248 2 => Self::ResponseInvalid,
2249
2250 3 => Self::StatusUnknown,
2251
2252 4 => Self::Unsupported,
2253
2254 _ => unsafe { ::core::hint::unreachable_unchecked() },
2255 }
2256 }
2257 }
2258
2259 impl ::fidl_next::FromWire<crate::wire::StatusError> for StatusError {
2260 #[inline]
2261 fn from_wire(wire: crate::wire::StatusError) -> Self {
2262 Self::from(wire)
2263 }
2264 }
2265
2266 impl ::fidl_next::FromWireRef<crate::wire::StatusError> for StatusError {
2267 #[inline]
2268 fn from_wire_ref(wire: &crate::wire::StatusError) -> Self {
2269 Self::from(*wire)
2270 }
2271 }
2272
2273 pub type StorageAdminOpenStorageResponse = ();
2274
2275 pub type StorageAdminListStorageInRealmResponse = ();
2276
2277 pub type StorageAdminOpenComponentStorageByIdResponse = ();
2278
2279 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2280 pub struct StorageAdminDeleteComponentStorageRequest {
2281 pub relative_moniker: ::std::string::String,
2282 }
2283
2284 unsafe impl<___E>
2285 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2286 for StorageAdminDeleteComponentStorageRequest
2287 where
2288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2289 ___E: ::fidl_next::Encoder,
2290 {
2291 #[inline]
2292 fn encode(
2293 self,
2294 encoder_: &mut ___E,
2295 out_: &mut ::core::mem::MaybeUninit<
2296 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2297 >,
2298 _: (),
2299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2300 ::fidl_next::munge! {
2301 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2302 relative_moniker,
2303
2304 } = out_;
2305 }
2306
2307 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
2308
2309 let mut _field =
2310 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2311 ::fidl_next::Constrained::validate(_field, 4096)?;
2312
2313 Ok(())
2314 }
2315 }
2316
2317 unsafe impl<'a, ___E>
2318 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
2319 for &'a StorageAdminDeleteComponentStorageRequest
2320 where
2321 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2322 ___E: ::fidl_next::Encoder,
2323 {
2324 #[inline]
2325 fn encode(
2326 self,
2327 encoder_: &mut ___E,
2328 out_: &mut ::core::mem::MaybeUninit<
2329 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2330 >,
2331 _: (),
2332 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2333 ::fidl_next::munge! {
2334 let crate::wire::StorageAdminDeleteComponentStorageRequest {
2335 relative_moniker,
2336
2337 } = out_;
2338 }
2339
2340 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
2341
2342 let mut _field =
2343 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
2344 ::fidl_next::Constrained::validate(_field, 4096)?;
2345
2346 Ok(())
2347 }
2348 }
2349
2350 unsafe impl<___E>
2351 ::fidl_next::EncodeOption<
2352 ::fidl_next::wire::Box<
2353 'static,
2354 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2355 >,
2356 ___E,
2357 > for StorageAdminDeleteComponentStorageRequest
2358 where
2359 ___E: ::fidl_next::Encoder + ?Sized,
2360 StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2361 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2362 ___E,
2363 >,
2364 {
2365 #[inline]
2366 fn encode_option(
2367 this: ::core::option::Option<Self>,
2368 encoder: &mut ___E,
2369 out: &mut ::core::mem::MaybeUninit<
2370 ::fidl_next::wire::Box<
2371 'static,
2372 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2373 >,
2374 >,
2375 _: (),
2376 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2377 if let Some(inner) = this {
2378 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2379 ::fidl_next::wire::Box::encode_present(out);
2380 } else {
2381 ::fidl_next::wire::Box::encode_absent(out);
2382 }
2383
2384 Ok(())
2385 }
2386 }
2387
2388 unsafe impl<'a, ___E>
2389 ::fidl_next::EncodeOption<
2390 ::fidl_next::wire::Box<
2391 'static,
2392 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2393 >,
2394 ___E,
2395 > for &'a StorageAdminDeleteComponentStorageRequest
2396 where
2397 ___E: ::fidl_next::Encoder + ?Sized,
2398 &'a StorageAdminDeleteComponentStorageRequest: ::fidl_next::Encode<
2399 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2400 ___E,
2401 >,
2402 {
2403 #[inline]
2404 fn encode_option(
2405 this: ::core::option::Option<Self>,
2406 encoder: &mut ___E,
2407 out: &mut ::core::mem::MaybeUninit<
2408 ::fidl_next::wire::Box<
2409 'static,
2410 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
2411 >,
2412 >,
2413 _: (),
2414 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2415 if let Some(inner) = this {
2416 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2417 ::fidl_next::wire::Box::encode_present(out);
2418 } else {
2419 ::fidl_next::wire::Box::encode_absent(out);
2420 }
2421
2422 Ok(())
2423 }
2424 }
2425
2426 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2427 for StorageAdminDeleteComponentStorageRequest
2428 {
2429 #[inline]
2430 fn from_wire(wire: crate::wire::StorageAdminDeleteComponentStorageRequest<'de>) -> Self {
2431 Self { relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker) }
2432 }
2433 }
2434
2435 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageAdminDeleteComponentStorageRequest<'de>>
2436 for StorageAdminDeleteComponentStorageRequest
2437 {
2438 #[inline]
2439 fn from_wire_ref(
2440 wire: &crate::wire::StorageAdminDeleteComponentStorageRequest<'de>,
2441 ) -> Self {
2442 Self {
2443 relative_moniker: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_moniker),
2444 }
2445 }
2446 }
2447
2448 pub type StorageAdminDeleteComponentStorageResponse = ();
2449
2450 #[doc = " Metadata about status of the storage\n"]
2451 #[derive(Debug, Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2452 pub struct StorageStatus {
2453 pub total_size: ::core::option::Option<u64>,
2454
2455 pub used_size: ::core::option::Option<u64>,
2456 }
2457
2458 impl StorageStatus {
2459 fn __max_ordinal(&self) -> usize {
2460 if self.used_size.is_some() {
2461 return 2;
2462 }
2463
2464 if self.total_size.is_some() {
2465 return 1;
2466 }
2467
2468 0
2469 }
2470 }
2471
2472 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E> for StorageStatus
2473 where
2474 ___E: ::fidl_next::Encoder + ?Sized,
2475 {
2476 #[inline]
2477 fn encode(
2478 mut self,
2479 encoder: &mut ___E,
2480 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2481 _: (),
2482 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2483 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2484
2485 let max_ord = self.__max_ordinal();
2486
2487 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2488 ::fidl_next::Wire::zero_padding(&mut out);
2489
2490 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2491 ::fidl_next::wire::Envelope,
2492 >(encoder, max_ord);
2493
2494 for i in 1..=max_ord {
2495 match i {
2496 2 => {
2497 if let Some(value) = self.used_size.take() {
2498 ::fidl_next::wire::Envelope::encode_value::<
2499 ::fidl_next::wire::Uint64,
2500 ___E,
2501 >(
2502 value, preallocated.encoder, &mut out, ()
2503 )?;
2504 } else {
2505 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2506 }
2507 }
2508
2509 1 => {
2510 if let Some(value) = self.total_size.take() {
2511 ::fidl_next::wire::Envelope::encode_value::<
2512 ::fidl_next::wire::Uint64,
2513 ___E,
2514 >(
2515 value, preallocated.encoder, &mut out, ()
2516 )?;
2517 } else {
2518 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2519 }
2520 }
2521
2522 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2523 }
2524 unsafe {
2525 preallocated.write_next(out.assume_init_ref());
2526 }
2527 }
2528
2529 ::fidl_next::wire::Table::encode_len(table, max_ord);
2530
2531 Ok(())
2532 }
2533 }
2534
2535 unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::StorageStatus<'static>, ___E>
2536 for &'a StorageStatus
2537 where
2538 ___E: ::fidl_next::Encoder + ?Sized,
2539 {
2540 #[inline]
2541 fn encode(
2542 self,
2543 encoder: &mut ___E,
2544 out: &mut ::core::mem::MaybeUninit<crate::wire::StorageStatus<'static>>,
2545 _: (),
2546 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2547 ::fidl_next::munge!(let crate::wire::StorageStatus { table } = out);
2548
2549 let max_ord = self.__max_ordinal();
2550
2551 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
2552 ::fidl_next::Wire::zero_padding(&mut out);
2553
2554 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
2555 ::fidl_next::wire::Envelope,
2556 >(encoder, max_ord);
2557
2558 for i in 1..=max_ord {
2559 match i {
2560 2 => {
2561 if let Some(value) = &self.used_size {
2562 ::fidl_next::wire::Envelope::encode_value::<
2563 ::fidl_next::wire::Uint64,
2564 ___E,
2565 >(
2566 value, preallocated.encoder, &mut out, ()
2567 )?;
2568 } else {
2569 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2570 }
2571 }
2572
2573 1 => {
2574 if let Some(value) = &self.total_size {
2575 ::fidl_next::wire::Envelope::encode_value::<
2576 ::fidl_next::wire::Uint64,
2577 ___E,
2578 >(
2579 value, preallocated.encoder, &mut out, ()
2580 )?;
2581 } else {
2582 ::fidl_next::wire::Envelope::encode_zero(&mut out)
2583 }
2584 }
2585
2586 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
2587 }
2588 unsafe {
2589 preallocated.write_next(out.assume_init_ref());
2590 }
2591 }
2592
2593 ::fidl_next::wire::Table::encode_len(table, max_ord);
2594
2595 Ok(())
2596 }
2597 }
2598
2599 impl<'de> ::fidl_next::FromWire<crate::wire::StorageStatus<'de>> for StorageStatus {
2600 #[inline]
2601 fn from_wire(wire_: crate::wire::StorageStatus<'de>) -> Self {
2602 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
2603
2604 let total_size = wire_.table.get(1);
2605
2606 let used_size = wire_.table.get(2);
2607
2608 Self {
2609 total_size: total_size.map(|envelope| {
2610 ::fidl_next::FromWire::from_wire(unsafe {
2611 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2612 })
2613 }),
2614
2615 used_size: used_size.map(|envelope| {
2616 ::fidl_next::FromWire::from_wire(unsafe {
2617 envelope.read_unchecked::<::fidl_next::wire::Uint64>()
2618 })
2619 }),
2620 }
2621 }
2622 }
2623
2624 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageStatus<'de>> for StorageStatus {
2625 #[inline]
2626 fn from_wire_ref(wire: &crate::wire::StorageStatus<'de>) -> Self {
2627 Self {
2628 total_size: wire.table.get(1).map(|envelope| {
2629 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2630 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2631 })
2632 }),
2633
2634 used_size: wire.table.get(2).map(|envelope| {
2635 ::fidl_next::FromWireRef::from_wire_ref(unsafe {
2636 envelope.deref_unchecked::<::fidl_next::wire::Uint64>()
2637 })
2638 }),
2639 }
2640 }
2641 }
2642
2643 pub type StorageAdminDeleteAllStorageContentsResponse = ();
2644
2645 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
2646 pub struct StorageIteratorNextResponse {
2647 pub relative_monikers: ::std::vec::Vec<::std::string::String>,
2648 }
2649
2650 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2651 for StorageIteratorNextResponse
2652 where
2653 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2654 ___E: ::fidl_next::Encoder,
2655 {
2656 #[inline]
2657 fn encode(
2658 self,
2659 encoder_: &mut ___E,
2660 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2661 _: (),
2662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2663 ::fidl_next::munge! {
2664 let crate::wire::StorageIteratorNextResponse {
2665 relative_monikers,
2666
2667 } = out_;
2668 }
2669
2670 ::fidl_next::Encode::encode(
2671 self.relative_monikers,
2672 encoder_,
2673 relative_monikers,
2674 (4294967295, 4096),
2675 )?;
2676
2677 let mut _field =
2678 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2679 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2680
2681 Ok(())
2682 }
2683 }
2684
2685 unsafe impl<'a, ___E>
2686 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
2687 for &'a StorageIteratorNextResponse
2688 where
2689 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2690 ___E: ::fidl_next::Encoder,
2691 {
2692 #[inline]
2693 fn encode(
2694 self,
2695 encoder_: &mut ___E,
2696 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
2697 _: (),
2698 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2699 ::fidl_next::munge! {
2700 let crate::wire::StorageIteratorNextResponse {
2701 relative_monikers,
2702
2703 } = out_;
2704 }
2705
2706 ::fidl_next::Encode::encode(
2707 &self.relative_monikers,
2708 encoder_,
2709 relative_monikers,
2710 (4294967295, 4096),
2711 )?;
2712
2713 let mut _field =
2714 unsafe { ::fidl_next::Slot::new_unchecked(relative_monikers.as_mut_ptr()) };
2715 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
2716
2717 Ok(())
2718 }
2719 }
2720
2721 unsafe impl<___E>
2722 ::fidl_next::EncodeOption<
2723 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2724 ___E,
2725 > for StorageIteratorNextResponse
2726 where
2727 ___E: ::fidl_next::Encoder + ?Sized,
2728 StorageIteratorNextResponse:
2729 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2730 {
2731 #[inline]
2732 fn encode_option(
2733 this: ::core::option::Option<Self>,
2734 encoder: &mut ___E,
2735 out: &mut ::core::mem::MaybeUninit<
2736 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2737 >,
2738 _: (),
2739 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2740 if let Some(inner) = this {
2741 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2742 ::fidl_next::wire::Box::encode_present(out);
2743 } else {
2744 ::fidl_next::wire::Box::encode_absent(out);
2745 }
2746
2747 Ok(())
2748 }
2749 }
2750
2751 unsafe impl<'a, ___E>
2752 ::fidl_next::EncodeOption<
2753 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2754 ___E,
2755 > for &'a StorageIteratorNextResponse
2756 where
2757 ___E: ::fidl_next::Encoder + ?Sized,
2758 &'a StorageIteratorNextResponse:
2759 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>,
2760 {
2761 #[inline]
2762 fn encode_option(
2763 this: ::core::option::Option<Self>,
2764 encoder: &mut ___E,
2765 out: &mut ::core::mem::MaybeUninit<
2766 ::fidl_next::wire::Box<'static, crate::wire::StorageIteratorNextResponse<'static>>,
2767 >,
2768 _: (),
2769 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2770 if let Some(inner) = this {
2771 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2772 ::fidl_next::wire::Box::encode_present(out);
2773 } else {
2774 ::fidl_next::wire::Box::encode_absent(out);
2775 }
2776
2777 Ok(())
2778 }
2779 }
2780
2781 impl<'de> ::fidl_next::FromWire<crate::wire::StorageIteratorNextResponse<'de>>
2782 for StorageIteratorNextResponse
2783 {
2784 #[inline]
2785 fn from_wire(wire: crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2786 Self { relative_monikers: ::fidl_next::FromWire::from_wire(wire.relative_monikers) }
2787 }
2788 }
2789
2790 impl<'de> ::fidl_next::FromWireRef<crate::wire::StorageIteratorNextResponse<'de>>
2791 for StorageIteratorNextResponse
2792 {
2793 #[inline]
2794 fn from_wire_ref(wire: &crate::wire::StorageIteratorNextResponse<'de>) -> Self {
2795 Self {
2796 relative_monikers: ::fidl_next::FromWireRef::from_wire_ref(&wire.relative_monikers),
2797 }
2798 }
2799 }
2800
2801 pub type ChildName = ::std::string::String;
2802
2803 pub type UrlScheme = ::std::string::String;
2804}
2805
2806pub mod wire {
2807
2808 pub type Name<'de> = ::fidl_next::wire::String<'de>;
2810
2811 #[derive(Debug)]
2813 #[repr(C)]
2814 pub struct ChildIteratorNextResponse<'de> {
2815 pub children: ::fidl_next::wire::Vector<
2816 'de,
2817 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
2818 >,
2819 }
2820
2821 static_assertions::const_assert_eq!(std::mem::size_of::<ChildIteratorNextResponse<'_>>(), 16);
2822 static_assertions::const_assert_eq!(std::mem::align_of::<ChildIteratorNextResponse<'_>>(), 8);
2823
2824 static_assertions::const_assert_eq!(
2825 std::mem::offset_of!(ChildIteratorNextResponse<'_>, children),
2826 0
2827 );
2828
2829 impl ::fidl_next::Constrained for ChildIteratorNextResponse<'_> {
2830 type Constraint = ();
2831
2832 fn validate(
2833 _: ::fidl_next::Slot<'_, Self>,
2834 _: Self::Constraint,
2835 ) -> Result<(), ::fidl_next::ValidationError> {
2836 Ok(())
2837 }
2838 }
2839
2840 unsafe impl ::fidl_next::Wire for ChildIteratorNextResponse<'static> {
2841 type Narrowed<'de> = ChildIteratorNextResponse<'de>;
2842
2843 #[inline]
2844 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
2845 ::fidl_next::munge! {
2846 let Self {
2847 children,
2848
2849 } = &mut *out_;
2850 }
2851
2852 ::fidl_next::Wire::zero_padding(children);
2853 }
2854 }
2855
2856 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ChildIteratorNextResponse<'de>
2857 where
2858 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
2859 ___D: ::fidl_next::Decoder<'de>,
2860 {
2861 fn decode(
2862 slot_: ::fidl_next::Slot<'_, Self>,
2863 decoder_: &mut ___D,
2864 _: (),
2865 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2866 ::fidl_next::munge! {
2867 let Self {
2868 mut children,
2869
2870 } = slot_;
2871 }
2872
2873 let _field = children.as_mut();
2874 ::fidl_next::Constrained::validate(_field, (128, ()))?;
2875 ::fidl_next::Decode::decode(children.as_mut(), decoder_, (128, ()))?;
2876
2877 let children = unsafe { children.deref_unchecked() };
2878
2879 if children.len() > 128 {
2880 return Err(::fidl_next::DecodeError::VectorTooLong {
2881 size: children.len() as u64,
2882 limit: 128,
2883 });
2884 }
2885
2886 Ok(())
2887 }
2888 }
2889
2890 impl<'de> ::fidl_next::IntoNatural for ChildIteratorNextResponse<'de> {
2891 type Natural = crate::natural::ChildIteratorNextResponse;
2892 }
2893
2894 pub type ControllerStartResponse = ::fidl_next::wire::Unit;
2896
2897 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
2899 #[repr(transparent)]
2900 pub struct Error {
2901 pub(crate) value: ::fidl_next::wire::Uint32,
2902 }
2903
2904 impl ::fidl_next::Constrained for Error {
2905 type Constraint = ();
2906
2907 fn validate(
2908 _: ::fidl_next::Slot<'_, Self>,
2909 _: Self::Constraint,
2910 ) -> Result<(), ::fidl_next::ValidationError> {
2911 Ok(())
2912 }
2913 }
2914
2915 unsafe impl ::fidl_next::Wire for Error {
2916 type Narrowed<'de> = Self;
2917
2918 #[inline]
2919 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
2920 }
2922 }
2923
2924 impl Error {
2925 pub const INTERNAL: Error = Error { value: ::fidl_next::wire::Uint32(1) };
2926
2927 pub const INVALID_ARGUMENTS: Error = Error { value: ::fidl_next::wire::Uint32(2) };
2928
2929 pub const UNSUPPORTED: Error = Error { value: ::fidl_next::wire::Uint32(3) };
2930
2931 pub const ACCESS_DENIED: Error = Error { value: ::fidl_next::wire::Uint32(4) };
2932
2933 pub const INSTANCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(5) };
2934
2935 pub const INSTANCE_ALREADY_EXISTS: Error = Error { value: ::fidl_next::wire::Uint32(6) };
2936
2937 pub const INSTANCE_CANNOT_START: Error = Error { value: ::fidl_next::wire::Uint32(7) };
2938
2939 pub const INSTANCE_CANNOT_RESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(8) };
2940
2941 pub const COLLECTION_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(9) };
2942
2943 pub const RESOURCE_UNAVAILABLE: Error = Error { value: ::fidl_next::wire::Uint32(10) };
2944
2945 pub const INSTANCE_DIED: Error = Error { value: ::fidl_next::wire::Uint32(11) };
2946
2947 pub const RESOURCE_NOT_FOUND: Error = Error { value: ::fidl_next::wire::Uint32(12) };
2948
2949 pub const INSTANCE_CANNOT_UNRESOLVE: Error = Error { value: ::fidl_next::wire::Uint32(13) };
2950
2951 pub const INSTANCE_ALREADY_STARTED: Error = Error { value: ::fidl_next::wire::Uint32(14) };
2952
2953 pub const DEPENDENCY_CYCLE: Error = Error { value: ::fidl_next::wire::Uint32(15) };
2954 }
2955
2956 unsafe impl<___D> ::fidl_next::Decode<___D> for Error
2957 where
2958 ___D: ?Sized,
2959 {
2960 fn decode(
2961 slot: ::fidl_next::Slot<'_, Self>,
2962 _: &mut ___D,
2963 _: (),
2964 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
2965 Ok(())
2966 }
2967 }
2968
2969 impl ::core::convert::From<crate::natural::Error> for Error {
2970 fn from(natural: crate::natural::Error) -> Self {
2971 match natural {
2972 crate::natural::Error::Internal => Error::INTERNAL,
2973
2974 crate::natural::Error::InvalidArguments => Error::INVALID_ARGUMENTS,
2975
2976 crate::natural::Error::Unsupported => Error::UNSUPPORTED,
2977
2978 crate::natural::Error::AccessDenied => Error::ACCESS_DENIED,
2979
2980 crate::natural::Error::InstanceNotFound => Error::INSTANCE_NOT_FOUND,
2981
2982 crate::natural::Error::InstanceAlreadyExists => Error::INSTANCE_ALREADY_EXISTS,
2983
2984 crate::natural::Error::InstanceCannotStart => Error::INSTANCE_CANNOT_START,
2985
2986 crate::natural::Error::InstanceCannotResolve => Error::INSTANCE_CANNOT_RESOLVE,
2987
2988 crate::natural::Error::CollectionNotFound => Error::COLLECTION_NOT_FOUND,
2989
2990 crate::natural::Error::ResourceUnavailable => Error::RESOURCE_UNAVAILABLE,
2991
2992 crate::natural::Error::InstanceDied => Error::INSTANCE_DIED,
2993
2994 crate::natural::Error::ResourceNotFound => Error::RESOURCE_NOT_FOUND,
2995
2996 crate::natural::Error::InstanceCannotUnresolve => Error::INSTANCE_CANNOT_UNRESOLVE,
2997
2998 crate::natural::Error::InstanceAlreadyStarted => Error::INSTANCE_ALREADY_STARTED,
2999
3000 crate::natural::Error::DependencyCycle => Error::DEPENDENCY_CYCLE,
3001
3002 crate::natural::Error::UnknownOrdinal_(value) => {
3003 Error { value: ::fidl_next::wire::Uint32::from(value) }
3004 }
3005 }
3006 }
3007 }
3008
3009 impl ::fidl_next::IntoNatural for Error {
3010 type Natural = crate::natural::Error;
3011 }
3012
3013 pub type ControllerOpenExposedDirResponse = ::fidl_next::wire::Unit;
3015
3016 pub type ControllerDestroyResponse = ::fidl_next::wire::Unit;
3018
3019 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3021 #[repr(transparent)]
3022 pub struct DeletionError {
3023 pub(crate) value: ::fidl_next::wire::Uint32,
3024 }
3025
3026 impl ::fidl_next::Constrained for DeletionError {
3027 type Constraint = ();
3028
3029 fn validate(
3030 _: ::fidl_next::Slot<'_, Self>,
3031 _: Self::Constraint,
3032 ) -> Result<(), ::fidl_next::ValidationError> {
3033 Ok(())
3034 }
3035 }
3036
3037 unsafe impl ::fidl_next::Wire for DeletionError {
3038 type Narrowed<'de> = Self;
3039
3040 #[inline]
3041 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3042 }
3044 }
3045
3046 impl DeletionError {
3047 pub const CONNECTION: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(1) };
3048
3049 pub const PROTOCOL: DeletionError = DeletionError { value: ::fidl_next::wire::Uint32(2) };
3050
3051 pub const NONE_AVAILABLE: DeletionError =
3052 DeletionError { value: ::fidl_next::wire::Uint32(3) };
3053
3054 pub const UNSUPPORTED: DeletionError =
3055 DeletionError { value: ::fidl_next::wire::Uint32(4) };
3056 }
3057
3058 unsafe impl<___D> ::fidl_next::Decode<___D> for DeletionError
3059 where
3060 ___D: ?Sized,
3061 {
3062 fn decode(
3063 slot: ::fidl_next::Slot<'_, Self>,
3064 _: &mut ___D,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3067 ::fidl_next::munge!(let Self { value } = slot);
3068
3069 match u32::from(*value) {
3070 1 | 2 | 3 | 4 => (),
3071 unknown => {
3072 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3073 }
3074 }
3075
3076 Ok(())
3077 }
3078 }
3079
3080 impl ::core::convert::From<crate::natural::DeletionError> for DeletionError {
3081 fn from(natural: crate::natural::DeletionError) -> Self {
3082 match natural {
3083 crate::natural::DeletionError::Connection => DeletionError::CONNECTION,
3084
3085 crate::natural::DeletionError::Protocol => DeletionError::PROTOCOL,
3086
3087 crate::natural::DeletionError::NoneAvailable => DeletionError::NONE_AVAILABLE,
3088
3089 crate::natural::DeletionError::Unsupported => DeletionError::UNSUPPORTED,
3090 }
3091 }
3092 }
3093
3094 impl ::fidl_next::IntoNatural for DeletionError {
3095 type Natural = crate::natural::DeletionError;
3096 }
3097
3098 #[repr(C)]
3100 pub struct DestroyedPayload<'de> {
3101 pub(crate) table: ::fidl_next::wire::Table<'de>,
3102 }
3103
3104 impl<'de> Drop for DestroyedPayload<'de> {
3105 fn drop(&mut self) {}
3106 }
3107
3108 impl ::fidl_next::Constrained for DestroyedPayload<'_> {
3109 type Constraint = ();
3110
3111 fn validate(
3112 _: ::fidl_next::Slot<'_, Self>,
3113 _: Self::Constraint,
3114 ) -> Result<(), ::fidl_next::ValidationError> {
3115 Ok(())
3116 }
3117 }
3118
3119 unsafe impl ::fidl_next::Wire for DestroyedPayload<'static> {
3120 type Narrowed<'de> = DestroyedPayload<'de>;
3121
3122 #[inline]
3123 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3124 ::fidl_next::munge!(let Self { table } = out);
3125 ::fidl_next::wire::Table::zero_padding(table);
3126 }
3127 }
3128
3129 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DestroyedPayload<'de>
3130 where
3131 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3132 {
3133 fn decode(
3134 slot: ::fidl_next::Slot<'_, Self>,
3135 decoder: &mut ___D,
3136 _: (),
3137 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3138 ::fidl_next::munge!(let Self { table } = slot);
3139
3140 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3141 match ordinal {
3142 0 => unsafe { ::core::hint::unreachable_unchecked() },
3143
3144 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3145 }
3146 })
3147 }
3148 }
3149
3150 impl<'de> DestroyedPayload<'de> {}
3151
3152 impl<'de> ::core::fmt::Debug for DestroyedPayload<'de> {
3153 fn fmt(
3154 &self,
3155 f: &mut ::core::fmt::Formatter<'_>,
3156 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3157 f.debug_struct("DestroyedPayload").finish()
3158 }
3159 }
3160
3161 impl<'de> ::fidl_next::IntoNatural for DestroyedPayload<'de> {
3162 type Natural = crate::natural::DestroyedPayload;
3163 }
3164
3165 #[repr(C)]
3167 pub struct DiscoveredPayload<'de> {
3168 pub(crate) table: ::fidl_next::wire::Table<'de>,
3169 }
3170
3171 impl<'de> Drop for DiscoveredPayload<'de> {
3172 fn drop(&mut self) {}
3173 }
3174
3175 impl ::fidl_next::Constrained for DiscoveredPayload<'_> {
3176 type Constraint = ();
3177
3178 fn validate(
3179 _: ::fidl_next::Slot<'_, Self>,
3180 _: Self::Constraint,
3181 ) -> Result<(), ::fidl_next::ValidationError> {
3182 Ok(())
3183 }
3184 }
3185
3186 unsafe impl ::fidl_next::Wire for DiscoveredPayload<'static> {
3187 type Narrowed<'de> = DiscoveredPayload<'de>;
3188
3189 #[inline]
3190 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3191 ::fidl_next::munge!(let Self { table } = out);
3192 ::fidl_next::wire::Table::zero_padding(table);
3193 }
3194 }
3195
3196 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DiscoveredPayload<'de>
3197 where
3198 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3199 {
3200 fn decode(
3201 slot: ::fidl_next::Slot<'_, Self>,
3202 decoder: &mut ___D,
3203 _: (),
3204 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3205 ::fidl_next::munge!(let Self { table } = slot);
3206
3207 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3208 match ordinal {
3209 0 => unsafe { ::core::hint::unreachable_unchecked() },
3210
3211 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3212 }
3213 })
3214 }
3215 }
3216
3217 impl<'de> DiscoveredPayload<'de> {}
3218
3219 impl<'de> ::core::fmt::Debug for DiscoveredPayload<'de> {
3220 fn fmt(
3221 &self,
3222 f: &mut ::core::fmt::Formatter<'_>,
3223 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3224 f.debug_struct("DiscoveredPayload").finish()
3225 }
3226 }
3227
3228 impl<'de> ::fidl_next::IntoNatural for DiscoveredPayload<'de> {
3229 type Natural = crate::natural::DiscoveredPayload;
3230 }
3231
3232 #[repr(C)]
3234 pub struct PurgedPayload<'de> {
3235 pub(crate) table: ::fidl_next::wire::Table<'de>,
3236 }
3237
3238 impl<'de> Drop for PurgedPayload<'de> {
3239 fn drop(&mut self) {}
3240 }
3241
3242 impl ::fidl_next::Constrained for PurgedPayload<'_> {
3243 type Constraint = ();
3244
3245 fn validate(
3246 _: ::fidl_next::Slot<'_, Self>,
3247 _: Self::Constraint,
3248 ) -> Result<(), ::fidl_next::ValidationError> {
3249 Ok(())
3250 }
3251 }
3252
3253 unsafe impl ::fidl_next::Wire for PurgedPayload<'static> {
3254 type Narrowed<'de> = PurgedPayload<'de>;
3255
3256 #[inline]
3257 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3258 ::fidl_next::munge!(let Self { table } = out);
3259 ::fidl_next::wire::Table::zero_padding(table);
3260 }
3261 }
3262
3263 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for PurgedPayload<'de>
3264 where
3265 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3266 {
3267 fn decode(
3268 slot: ::fidl_next::Slot<'_, Self>,
3269 decoder: &mut ___D,
3270 _: (),
3271 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3272 ::fidl_next::munge!(let Self { table } = slot);
3273
3274 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3275 match ordinal {
3276 0 => unsafe { ::core::hint::unreachable_unchecked() },
3277
3278 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3279 }
3280 })
3281 }
3282 }
3283
3284 impl<'de> PurgedPayload<'de> {}
3285
3286 impl<'de> ::core::fmt::Debug for PurgedPayload<'de> {
3287 fn fmt(
3288 &self,
3289 f: &mut ::core::fmt::Formatter<'_>,
3290 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3291 f.debug_struct("PurgedPayload").finish()
3292 }
3293 }
3294
3295 impl<'de> ::fidl_next::IntoNatural for PurgedPayload<'de> {
3296 type Natural = crate::natural::PurgedPayload;
3297 }
3298
3299 #[repr(C)]
3301 pub struct ResolvedPayload<'de> {
3302 pub(crate) table: ::fidl_next::wire::Table<'de>,
3303 }
3304
3305 impl<'de> Drop for ResolvedPayload<'de> {
3306 fn drop(&mut self) {}
3307 }
3308
3309 impl ::fidl_next::Constrained for ResolvedPayload<'_> {
3310 type Constraint = ();
3311
3312 fn validate(
3313 _: ::fidl_next::Slot<'_, Self>,
3314 _: Self::Constraint,
3315 ) -> Result<(), ::fidl_next::ValidationError> {
3316 Ok(())
3317 }
3318 }
3319
3320 unsafe impl ::fidl_next::Wire for ResolvedPayload<'static> {
3321 type Narrowed<'de> = ResolvedPayload<'de>;
3322
3323 #[inline]
3324 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3325 ::fidl_next::munge!(let Self { table } = out);
3326 ::fidl_next::wire::Table::zero_padding(table);
3327 }
3328 }
3329
3330 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ResolvedPayload<'de>
3331 where
3332 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3333 {
3334 fn decode(
3335 slot: ::fidl_next::Slot<'_, Self>,
3336 decoder: &mut ___D,
3337 _: (),
3338 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3339 ::fidl_next::munge!(let Self { table } = slot);
3340
3341 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3342 match ordinal {
3343 0 => unsafe { ::core::hint::unreachable_unchecked() },
3344
3345 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3346 }
3347 })
3348 }
3349 }
3350
3351 impl<'de> ResolvedPayload<'de> {}
3352
3353 impl<'de> ::core::fmt::Debug for ResolvedPayload<'de> {
3354 fn fmt(
3355 &self,
3356 f: &mut ::core::fmt::Formatter<'_>,
3357 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3358 f.debug_struct("ResolvedPayload").finish()
3359 }
3360 }
3361
3362 impl<'de> ::fidl_next::IntoNatural for ResolvedPayload<'de> {
3363 type Natural = crate::natural::ResolvedPayload;
3364 }
3365
3366 #[repr(C)]
3368 pub struct StartedPayload<'de> {
3369 pub(crate) table: ::fidl_next::wire::Table<'de>,
3370 }
3371
3372 impl<'de> Drop for StartedPayload<'de> {
3373 fn drop(&mut self) {}
3374 }
3375
3376 impl ::fidl_next::Constrained for StartedPayload<'_> {
3377 type Constraint = ();
3378
3379 fn validate(
3380 _: ::fidl_next::Slot<'_, Self>,
3381 _: Self::Constraint,
3382 ) -> Result<(), ::fidl_next::ValidationError> {
3383 Ok(())
3384 }
3385 }
3386
3387 unsafe impl ::fidl_next::Wire for StartedPayload<'static> {
3388 type Narrowed<'de> = StartedPayload<'de>;
3389
3390 #[inline]
3391 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3392 ::fidl_next::munge!(let Self { table } = out);
3393 ::fidl_next::wire::Table::zero_padding(table);
3394 }
3395 }
3396
3397 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartedPayload<'de>
3398 where
3399 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3400 {
3401 fn decode(
3402 slot: ::fidl_next::Slot<'_, Self>,
3403 decoder: &mut ___D,
3404 _: (),
3405 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3406 ::fidl_next::munge!(let Self { table } = slot);
3407
3408 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3409 match ordinal {
3410 0 => unsafe { ::core::hint::unreachable_unchecked() },
3411
3412 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3413 }
3414 })
3415 }
3416 }
3417
3418 impl<'de> StartedPayload<'de> {}
3419
3420 impl<'de> ::core::fmt::Debug for StartedPayload<'de> {
3421 fn fmt(
3422 &self,
3423 f: &mut ::core::fmt::Formatter<'_>,
3424 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3425 f.debug_struct("StartedPayload").finish()
3426 }
3427 }
3428
3429 impl<'de> ::fidl_next::IntoNatural for StartedPayload<'de> {
3430 type Natural = crate::natural::StartedPayload;
3431 }
3432
3433 #[repr(C)]
3435 pub struct UnresolvedPayload<'de> {
3436 pub(crate) table: ::fidl_next::wire::Table<'de>,
3437 }
3438
3439 impl<'de> Drop for UnresolvedPayload<'de> {
3440 fn drop(&mut self) {}
3441 }
3442
3443 impl ::fidl_next::Constrained for UnresolvedPayload<'_> {
3444 type Constraint = ();
3445
3446 fn validate(
3447 _: ::fidl_next::Slot<'_, Self>,
3448 _: Self::Constraint,
3449 ) -> Result<(), ::fidl_next::ValidationError> {
3450 Ok(())
3451 }
3452 }
3453
3454 unsafe impl ::fidl_next::Wire for UnresolvedPayload<'static> {
3455 type Narrowed<'de> = UnresolvedPayload<'de>;
3456
3457 #[inline]
3458 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3459 ::fidl_next::munge!(let Self { table } = out);
3460 ::fidl_next::wire::Table::zero_padding(table);
3461 }
3462 }
3463
3464 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for UnresolvedPayload<'de>
3465 where
3466 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3467 {
3468 fn decode(
3469 slot: ::fidl_next::Slot<'_, Self>,
3470 decoder: &mut ___D,
3471 _: (),
3472 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3473 ::fidl_next::munge!(let Self { table } = slot);
3474
3475 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3476 match ordinal {
3477 0 => unsafe { ::core::hint::unreachable_unchecked() },
3478
3479 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3480 }
3481 })
3482 }
3483 }
3484
3485 impl<'de> UnresolvedPayload<'de> {}
3486
3487 impl<'de> ::core::fmt::Debug for UnresolvedPayload<'de> {
3488 fn fmt(
3489 &self,
3490 f: &mut ::core::fmt::Formatter<'_>,
3491 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3492 f.debug_struct("UnresolvedPayload").finish()
3493 }
3494 }
3495
3496 impl<'de> ::fidl_next::IntoNatural for UnresolvedPayload<'de> {
3497 type Natural = crate::natural::UnresolvedPayload;
3498 }
3499
3500 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
3502 #[repr(transparent)]
3503 pub struct EventType {
3504 pub(crate) value: ::fidl_next::wire::Uint32,
3505 }
3506
3507 impl ::fidl_next::Constrained for EventType {
3508 type Constraint = ();
3509
3510 fn validate(
3511 _: ::fidl_next::Slot<'_, Self>,
3512 _: Self::Constraint,
3513 ) -> Result<(), ::fidl_next::ValidationError> {
3514 Ok(())
3515 }
3516 }
3517
3518 unsafe impl ::fidl_next::Wire for EventType {
3519 type Narrowed<'de> = Self;
3520
3521 #[inline]
3522 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
3523 }
3525 }
3526
3527 impl EventType {
3528 pub const CAPABILITY_REQUESTED: EventType =
3529 EventType { value: ::fidl_next::wire::Uint32(1) };
3530
3531 pub const DISCOVERED: EventType = EventType { value: ::fidl_next::wire::Uint32(3) };
3532
3533 pub const DESTROYED: EventType = EventType { value: ::fidl_next::wire::Uint32(4) };
3534
3535 pub const RESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(5) };
3536
3537 pub const STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(6) };
3538
3539 pub const STOPPED: EventType = EventType { value: ::fidl_next::wire::Uint32(7) };
3540
3541 pub const DEBUG_STARTED: EventType = EventType { value: ::fidl_next::wire::Uint32(8) };
3542
3543 pub const UNRESOLVED: EventType = EventType { value: ::fidl_next::wire::Uint32(9) };
3544 }
3545
3546 unsafe impl<___D> ::fidl_next::Decode<___D> for EventType
3547 where
3548 ___D: ?Sized,
3549 {
3550 fn decode(
3551 slot: ::fidl_next::Slot<'_, Self>,
3552 _: &mut ___D,
3553 _: (),
3554 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3555 ::fidl_next::munge!(let Self { value } = slot);
3556
3557 match u32::from(*value) {
3558 1 | 3 | 4 | 5 | 6 | 7 | 8 | 9 => (),
3559 unknown => {
3560 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
3561 }
3562 }
3563
3564 Ok(())
3565 }
3566 }
3567
3568 impl ::core::convert::From<crate::natural::EventType> for EventType {
3569 fn from(natural: crate::natural::EventType) -> Self {
3570 match natural {
3571 crate::natural::EventType::CapabilityRequested => EventType::CAPABILITY_REQUESTED,
3572
3573 crate::natural::EventType::Discovered => EventType::DISCOVERED,
3574
3575 crate::natural::EventType::Destroyed => EventType::DESTROYED,
3576
3577 crate::natural::EventType::Resolved => EventType::RESOLVED,
3578
3579 crate::natural::EventType::Started => EventType::STARTED,
3580
3581 crate::natural::EventType::Stopped => EventType::STOPPED,
3582
3583 crate::natural::EventType::DebugStarted => EventType::DEBUG_STARTED,
3584
3585 crate::natural::EventType::Unresolved => EventType::UNRESOLVED,
3586 }
3587 }
3588 }
3589
3590 impl ::fidl_next::IntoNatural for EventType {
3591 type Natural = crate::natural::EventType;
3592 }
3593
3594 #[repr(C)]
3596 pub struct StoppedPayload<'de> {
3597 pub(crate) table: ::fidl_next::wire::Table<'de>,
3598 }
3599
3600 impl<'de> Drop for StoppedPayload<'de> {
3601 fn drop(&mut self) {
3602 let _ = self
3603 .table
3604 .get(1)
3605 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int32>() });
3606
3607 let _ = self
3608 .table
3609 .get(2)
3610 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3611 }
3612 }
3613
3614 impl ::fidl_next::Constrained for StoppedPayload<'_> {
3615 type Constraint = ();
3616
3617 fn validate(
3618 _: ::fidl_next::Slot<'_, Self>,
3619 _: Self::Constraint,
3620 ) -> Result<(), ::fidl_next::ValidationError> {
3621 Ok(())
3622 }
3623 }
3624
3625 unsafe impl ::fidl_next::Wire for StoppedPayload<'static> {
3626 type Narrowed<'de> = StoppedPayload<'de>;
3627
3628 #[inline]
3629 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3630 ::fidl_next::munge!(let Self { table } = out);
3631 ::fidl_next::wire::Table::zero_padding(table);
3632 }
3633 }
3634
3635 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StoppedPayload<'de>
3636 where
3637 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3638 {
3639 fn decode(
3640 slot: ::fidl_next::Slot<'_, Self>,
3641 decoder: &mut ___D,
3642 _: (),
3643 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3644 ::fidl_next::munge!(let Self { table } = slot);
3645
3646 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3647 match ordinal {
3648 0 => unsafe { ::core::hint::unreachable_unchecked() },
3649
3650 1 => {
3651 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int32>(
3652 slot.as_mut(),
3653 decoder,
3654 (),
3655 )?;
3656
3657 Ok(())
3658 }
3659
3660 2 => {
3661 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3662 slot.as_mut(),
3663 decoder,
3664 (),
3665 )?;
3666
3667 Ok(())
3668 }
3669
3670 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3671 }
3672 })
3673 }
3674 }
3675
3676 impl<'de> StoppedPayload<'de> {
3677 pub fn status(&self) -> ::core::option::Option<&::fidl_next::wire::Int32> {
3678 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3679 }
3680
3681 pub fn exit_code(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3682 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3683 }
3684 }
3685
3686 impl<'de> ::core::fmt::Debug for StoppedPayload<'de> {
3687 fn fmt(
3688 &self,
3689 f: &mut ::core::fmt::Formatter<'_>,
3690 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3691 f.debug_struct("StoppedPayload")
3692 .field("status", &self.status())
3693 .field("exit_code", &self.exit_code())
3694 .finish()
3695 }
3696 }
3697
3698 impl<'de> ::fidl_next::IntoNatural for StoppedPayload<'de> {
3699 type Natural = crate::natural::StoppedPayload;
3700 }
3701
3702 #[repr(C)]
3704 pub struct EventHeader<'de> {
3705 pub(crate) table: ::fidl_next::wire::Table<'de>,
3706 }
3707
3708 impl<'de> Drop for EventHeader<'de> {
3709 fn drop(&mut self) {
3710 let _ = self
3711 .table
3712 .get(1)
3713 .map(|envelope| unsafe { envelope.read_unchecked::<crate::wire::EventType>() });
3714
3715 let _ = self.table.get(2).map(|envelope| unsafe {
3716 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3717 });
3718
3719 let _ = self.table.get(3).map(|envelope| unsafe {
3720 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3721 });
3722
3723 let _ = self
3724 .table
3725 .get(4)
3726 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Int64>() });
3727 }
3728 }
3729
3730 impl ::fidl_next::Constrained for EventHeader<'_> {
3731 type Constraint = ();
3732
3733 fn validate(
3734 _: ::fidl_next::Slot<'_, Self>,
3735 _: Self::Constraint,
3736 ) -> Result<(), ::fidl_next::ValidationError> {
3737 Ok(())
3738 }
3739 }
3740
3741 unsafe impl ::fidl_next::Wire for EventHeader<'static> {
3742 type Narrowed<'de> = EventHeader<'de>;
3743
3744 #[inline]
3745 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3746 ::fidl_next::munge!(let Self { table } = out);
3747 ::fidl_next::wire::Table::zero_padding(table);
3748 }
3749 }
3750
3751 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventHeader<'de>
3752 where
3753 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3754 {
3755 fn decode(
3756 slot: ::fidl_next::Slot<'_, Self>,
3757 decoder: &mut ___D,
3758 _: (),
3759 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3760 ::fidl_next::munge!(let Self { table } = slot);
3761
3762 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3763 match ordinal {
3764 0 => unsafe { ::core::hint::unreachable_unchecked() },
3765
3766 1 => {
3767 ::fidl_next::wire::Envelope::decode_as::<___D, crate::wire::EventType>(
3768 slot.as_mut(),
3769 decoder,
3770 (),
3771 )?;
3772
3773 Ok(())
3774 }
3775
3776 2 => {
3777 ::fidl_next::wire::Envelope::decode_as::<
3778 ___D,
3779 ::fidl_next::wire::String<'de>,
3780 >(slot.as_mut(), decoder, 4096)?;
3781
3782 let value = unsafe {
3783 slot.deref_unchecked()
3784 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3785 };
3786
3787 if value.len() > 4096 {
3788 return Err(::fidl_next::DecodeError::VectorTooLong {
3789 size: value.len() as u64,
3790 limit: 4096,
3791 });
3792 }
3793
3794 Ok(())
3795 }
3796
3797 3 => {
3798 ::fidl_next::wire::Envelope::decode_as::<
3799 ___D,
3800 ::fidl_next::wire::String<'de>,
3801 >(slot.as_mut(), decoder, 4096)?;
3802
3803 let value = unsafe {
3804 slot.deref_unchecked()
3805 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3806 };
3807
3808 if value.len() > 4096 {
3809 return Err(::fidl_next::DecodeError::VectorTooLong {
3810 size: value.len() as u64,
3811 limit: 4096,
3812 });
3813 }
3814
3815 Ok(())
3816 }
3817
3818 4 => {
3819 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Int64>(
3820 slot.as_mut(),
3821 decoder,
3822 (),
3823 )?;
3824
3825 Ok(())
3826 }
3827
3828 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3829 }
3830 })
3831 }
3832 }
3833
3834 impl<'de> EventHeader<'de> {
3835 pub fn event_type(&self) -> ::core::option::Option<&crate::wire::EventType> {
3836 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3837 }
3838
3839 pub fn moniker(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3840 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3841 }
3842
3843 pub fn component_url(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3844 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3845 }
3846
3847 pub fn timestamp(&self) -> ::core::option::Option<&::fidl_next::wire::Int64> {
3848 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3849 }
3850 }
3851
3852 impl<'de> ::core::fmt::Debug for EventHeader<'de> {
3853 fn fmt(
3854 &self,
3855 f: &mut ::core::fmt::Formatter<'_>,
3856 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3857 f.debug_struct("EventHeader")
3858 .field("event_type", &self.event_type())
3859 .field("moniker", &self.moniker())
3860 .field("component_url", &self.component_url())
3861 .field("timestamp", &self.timestamp())
3862 .finish()
3863 }
3864 }
3865
3866 impl<'de> ::fidl_next::IntoNatural for EventHeader<'de> {
3867 type Natural = crate::natural::EventHeader;
3868 }
3869
3870 #[derive(Debug)]
3872 #[repr(C)]
3873 pub struct ExecutionControllerOnStopRequest<'de> {
3874 pub stopped_payload: crate::wire::StoppedPayload<'de>,
3875 }
3876
3877 static_assertions::const_assert_eq!(
3878 std::mem::size_of::<ExecutionControllerOnStopRequest<'_>>(),
3879 16
3880 );
3881 static_assertions::const_assert_eq!(
3882 std::mem::align_of::<ExecutionControllerOnStopRequest<'_>>(),
3883 8
3884 );
3885
3886 static_assertions::const_assert_eq!(
3887 std::mem::offset_of!(ExecutionControllerOnStopRequest<'_>, stopped_payload),
3888 0
3889 );
3890
3891 impl ::fidl_next::Constrained for ExecutionControllerOnStopRequest<'_> {
3892 type Constraint = ();
3893
3894 fn validate(
3895 _: ::fidl_next::Slot<'_, Self>,
3896 _: Self::Constraint,
3897 ) -> Result<(), ::fidl_next::ValidationError> {
3898 Ok(())
3899 }
3900 }
3901
3902 unsafe impl ::fidl_next::Wire for ExecutionControllerOnStopRequest<'static> {
3903 type Narrowed<'de> = ExecutionControllerOnStopRequest<'de>;
3904
3905 #[inline]
3906 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3907 ::fidl_next::munge! {
3908 let Self {
3909 stopped_payload,
3910
3911 } = &mut *out_;
3912 }
3913
3914 ::fidl_next::Wire::zero_padding(stopped_payload);
3915 }
3916 }
3917
3918 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ExecutionControllerOnStopRequest<'de>
3919 where
3920 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3921 ___D: ::fidl_next::Decoder<'de>,
3922 {
3923 fn decode(
3924 slot_: ::fidl_next::Slot<'_, Self>,
3925 decoder_: &mut ___D,
3926 _: (),
3927 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3928 ::fidl_next::munge! {
3929 let Self {
3930 mut stopped_payload,
3931
3932 } = slot_;
3933 }
3934
3935 let _field = stopped_payload.as_mut();
3936
3937 ::fidl_next::Decode::decode(stopped_payload.as_mut(), decoder_, ())?;
3938
3939 Ok(())
3940 }
3941 }
3942
3943 impl<'de> ::fidl_next::IntoNatural for ExecutionControllerOnStopRequest<'de> {
3944 type Natural = crate::natural::ExecutionControllerOnStopRequest;
3945 }
3946
3947 #[derive(Debug)]
3949 #[repr(C)]
3950 pub struct IntrospectorGetMonikerResponse<'de> {
3951 pub moniker: ::fidl_next::wire::String<'de>,
3952 }
3953
3954 static_assertions::const_assert_eq!(
3955 std::mem::size_of::<IntrospectorGetMonikerResponse<'_>>(),
3956 16
3957 );
3958 static_assertions::const_assert_eq!(
3959 std::mem::align_of::<IntrospectorGetMonikerResponse<'_>>(),
3960 8
3961 );
3962
3963 static_assertions::const_assert_eq!(
3964 std::mem::offset_of!(IntrospectorGetMonikerResponse<'_>, moniker),
3965 0
3966 );
3967
3968 impl ::fidl_next::Constrained for IntrospectorGetMonikerResponse<'_> {
3969 type Constraint = ();
3970
3971 fn validate(
3972 _: ::fidl_next::Slot<'_, Self>,
3973 _: Self::Constraint,
3974 ) -> Result<(), ::fidl_next::ValidationError> {
3975 Ok(())
3976 }
3977 }
3978
3979 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerResponse<'static> {
3980 type Narrowed<'de> = IntrospectorGetMonikerResponse<'de>;
3981
3982 #[inline]
3983 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3984 ::fidl_next::munge! {
3985 let Self {
3986 moniker,
3987
3988 } = &mut *out_;
3989 }
3990
3991 ::fidl_next::Wire::zero_padding(moniker);
3992 }
3993 }
3994
3995 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerResponse<'de>
3996 where
3997 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3998 ___D: ::fidl_next::Decoder<'de>,
3999 {
4000 fn decode(
4001 slot_: ::fidl_next::Slot<'_, Self>,
4002 decoder_: &mut ___D,
4003 _: (),
4004 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4005 ::fidl_next::munge! {
4006 let Self {
4007 mut moniker,
4008
4009 } = slot_;
4010 }
4011
4012 let _field = moniker.as_mut();
4013 ::fidl_next::Constrained::validate(_field, 4096)?;
4014 ::fidl_next::Decode::decode(moniker.as_mut(), decoder_, 4096)?;
4015
4016 let moniker = unsafe { moniker.deref_unchecked() };
4017
4018 if moniker.len() > 4096 {
4019 return Err(::fidl_next::DecodeError::VectorTooLong {
4020 size: moniker.len() as u64,
4021 limit: 4096,
4022 });
4023 }
4024
4025 Ok(())
4026 }
4027 }
4028
4029 impl<'de> ::fidl_next::IntoNatural for IntrospectorGetMonikerResponse<'de> {
4030 type Natural = crate::natural::IntrospectorGetMonikerResponse;
4031 }
4032
4033 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4035 #[repr(transparent)]
4036 pub struct NamespaceError {
4037 pub(crate) value: ::fidl_next::wire::Uint32,
4038 }
4039
4040 impl ::fidl_next::Constrained for NamespaceError {
4041 type Constraint = ();
4042
4043 fn validate(
4044 _: ::fidl_next::Slot<'_, Self>,
4045 _: Self::Constraint,
4046 ) -> Result<(), ::fidl_next::ValidationError> {
4047 Ok(())
4048 }
4049 }
4050
4051 unsafe impl ::fidl_next::Wire for NamespaceError {
4052 type Narrowed<'de> = Self;
4053
4054 #[inline]
4055 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4056 }
4058 }
4059
4060 impl NamespaceError {
4061 pub const SHADOW: NamespaceError = NamespaceError { value: ::fidl_next::wire::Uint32(1) };
4062
4063 pub const DUPLICATE: NamespaceError =
4064 NamespaceError { value: ::fidl_next::wire::Uint32(2) };
4065
4066 pub const CONVERSION: NamespaceError =
4067 NamespaceError { value: ::fidl_next::wire::Uint32(3) };
4068
4069 pub const BAD_ENTRY: NamespaceError =
4070 NamespaceError { value: ::fidl_next::wire::Uint32(4) };
4071
4072 pub const DICTIONARY_READ: NamespaceError =
4073 NamespaceError { value: ::fidl_next::wire::Uint32(5) };
4074 }
4075
4076 unsafe impl<___D> ::fidl_next::Decode<___D> for NamespaceError
4077 where
4078 ___D: ?Sized,
4079 {
4080 fn decode(
4081 slot: ::fidl_next::Slot<'_, Self>,
4082 _: &mut ___D,
4083 _: (),
4084 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4085 Ok(())
4086 }
4087 }
4088
4089 impl ::core::convert::From<crate::natural::NamespaceError> for NamespaceError {
4090 fn from(natural: crate::natural::NamespaceError) -> Self {
4091 match natural {
4092 crate::natural::NamespaceError::Shadow => NamespaceError::SHADOW,
4093
4094 crate::natural::NamespaceError::Duplicate => NamespaceError::DUPLICATE,
4095
4096 crate::natural::NamespaceError::Conversion => NamespaceError::CONVERSION,
4097
4098 crate::natural::NamespaceError::BadEntry => NamespaceError::BAD_ENTRY,
4099
4100 crate::natural::NamespaceError::DictionaryRead => NamespaceError::DICTIONARY_READ,
4101
4102 crate::natural::NamespaceError::UnknownOrdinal_(value) => {
4103 NamespaceError { value: ::fidl_next::wire::Uint32::from(value) }
4104 }
4105 }
4106 }
4107 }
4108
4109 impl ::fidl_next::IntoNatural for NamespaceError {
4110 type Natural = crate::natural::NamespaceError;
4111 }
4112
4113 pub type RealmOpenExposedDirResponse = ::fidl_next::wire::Unit;
4115
4116 pub type RealmCreateChildResponse = ::fidl_next::wire::Unit;
4118
4119 #[derive(Debug)]
4121 #[repr(C)]
4122 pub struct RealmDestroyChildRequest<'de> {
4123 pub child: ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'de>,
4124 }
4125
4126 static_assertions::const_assert_eq!(std::mem::size_of::<RealmDestroyChildRequest<'_>>(), 32);
4127 static_assertions::const_assert_eq!(std::mem::align_of::<RealmDestroyChildRequest<'_>>(), 8);
4128
4129 static_assertions::const_assert_eq!(
4130 std::mem::offset_of!(RealmDestroyChildRequest<'_>, child),
4131 0
4132 );
4133
4134 impl ::fidl_next::Constrained for RealmDestroyChildRequest<'_> {
4135 type Constraint = ();
4136
4137 fn validate(
4138 _: ::fidl_next::Slot<'_, Self>,
4139 _: Self::Constraint,
4140 ) -> Result<(), ::fidl_next::ValidationError> {
4141 Ok(())
4142 }
4143 }
4144
4145 unsafe impl ::fidl_next::Wire for RealmDestroyChildRequest<'static> {
4146 type Narrowed<'de> = RealmDestroyChildRequest<'de>;
4147
4148 #[inline]
4149 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4150 ::fidl_next::munge! {
4151 let Self {
4152 child,
4153
4154 } = &mut *out_;
4155 }
4156
4157 ::fidl_next::Wire::zero_padding(child);
4158 }
4159 }
4160
4161 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmDestroyChildRequest<'de>
4162 where
4163 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4164 ___D: ::fidl_next::Decoder<'de>,
4165 {
4166 fn decode(
4167 slot_: ::fidl_next::Slot<'_, Self>,
4168 decoder_: &mut ___D,
4169 _: (),
4170 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4171 ::fidl_next::munge! {
4172 let Self {
4173 mut child,
4174
4175 } = slot_;
4176 }
4177
4178 let _field = child.as_mut();
4179
4180 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
4181
4182 Ok(())
4183 }
4184 }
4185
4186 impl<'de> ::fidl_next::IntoNatural for RealmDestroyChildRequest<'de> {
4187 type Natural = crate::natural::RealmDestroyChildRequest;
4188 }
4189
4190 pub type RealmDestroyChildResponse = ::fidl_next::wire::Unit;
4192
4193 pub type RealmListChildrenResponse = ::fidl_next::wire::Unit;
4195
4196 pub type RealmOpenControllerResponse = ::fidl_next::wire::Unit;
4198
4199 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
4201 #[repr(transparent)]
4202 pub struct StatusError {
4203 pub(crate) value: ::fidl_next::wire::Uint32,
4204 }
4205
4206 impl ::fidl_next::Constrained for StatusError {
4207 type Constraint = ();
4208
4209 fn validate(
4210 _: ::fidl_next::Slot<'_, Self>,
4211 _: Self::Constraint,
4212 ) -> Result<(), ::fidl_next::ValidationError> {
4213 Ok(())
4214 }
4215 }
4216
4217 unsafe impl ::fidl_next::Wire for StatusError {
4218 type Narrowed<'de> = Self;
4219
4220 #[inline]
4221 fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
4222 }
4224 }
4225
4226 impl StatusError {
4227 pub const PROVIDER: StatusError = StatusError { value: ::fidl_next::wire::Uint32(1) };
4228
4229 pub const RESPONSE_INVALID: StatusError =
4230 StatusError { value: ::fidl_next::wire::Uint32(2) };
4231
4232 pub const STATUS_UNKNOWN: StatusError = StatusError { value: ::fidl_next::wire::Uint32(3) };
4233
4234 pub const UNSUPPORTED: StatusError = StatusError { value: ::fidl_next::wire::Uint32(4) };
4235 }
4236
4237 unsafe impl<___D> ::fidl_next::Decode<___D> for StatusError
4238 where
4239 ___D: ?Sized,
4240 {
4241 fn decode(
4242 slot: ::fidl_next::Slot<'_, Self>,
4243 _: &mut ___D,
4244 _: (),
4245 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4246 ::fidl_next::munge!(let Self { value } = slot);
4247
4248 match u32::from(*value) {
4249 1 | 2 | 3 | 4 => (),
4250 unknown => {
4251 return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128));
4252 }
4253 }
4254
4255 Ok(())
4256 }
4257 }
4258
4259 impl ::core::convert::From<crate::natural::StatusError> for StatusError {
4260 fn from(natural: crate::natural::StatusError) -> Self {
4261 match natural {
4262 crate::natural::StatusError::Provider => StatusError::PROVIDER,
4263
4264 crate::natural::StatusError::ResponseInvalid => StatusError::RESPONSE_INVALID,
4265
4266 crate::natural::StatusError::StatusUnknown => StatusError::STATUS_UNKNOWN,
4267
4268 crate::natural::StatusError::Unsupported => StatusError::UNSUPPORTED,
4269 }
4270 }
4271 }
4272
4273 impl ::fidl_next::IntoNatural for StatusError {
4274 type Natural = crate::natural::StatusError;
4275 }
4276
4277 pub type StorageAdminOpenStorageResponse = ::fidl_next::wire::Unit;
4279
4280 pub type StorageAdminListStorageInRealmResponse = ::fidl_next::wire::Unit;
4282
4283 pub type StorageAdminOpenComponentStorageByIdResponse = ::fidl_next::wire::Unit;
4285
4286 #[derive(Debug)]
4288 #[repr(C)]
4289 pub struct StorageAdminDeleteComponentStorageRequest<'de> {
4290 pub relative_moniker: ::fidl_next::wire::String<'de>,
4291 }
4292
4293 static_assertions::const_assert_eq!(
4294 std::mem::size_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4295 16
4296 );
4297 static_assertions::const_assert_eq!(
4298 std::mem::align_of::<StorageAdminDeleteComponentStorageRequest<'_>>(),
4299 8
4300 );
4301
4302 static_assertions::const_assert_eq!(
4303 std::mem::offset_of!(StorageAdminDeleteComponentStorageRequest<'_>, relative_moniker),
4304 0
4305 );
4306
4307 impl ::fidl_next::Constrained for StorageAdminDeleteComponentStorageRequest<'_> {
4308 type Constraint = ();
4309
4310 fn validate(
4311 _: ::fidl_next::Slot<'_, Self>,
4312 _: Self::Constraint,
4313 ) -> Result<(), ::fidl_next::ValidationError> {
4314 Ok(())
4315 }
4316 }
4317
4318 unsafe impl ::fidl_next::Wire for StorageAdminDeleteComponentStorageRequest<'static> {
4319 type Narrowed<'de> = StorageAdminDeleteComponentStorageRequest<'de>;
4320
4321 #[inline]
4322 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4323 ::fidl_next::munge! {
4324 let Self {
4325 relative_moniker,
4326
4327 } = &mut *out_;
4328 }
4329
4330 ::fidl_next::Wire::zero_padding(relative_moniker);
4331 }
4332 }
4333
4334 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminDeleteComponentStorageRequest<'de>
4335 where
4336 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4337 ___D: ::fidl_next::Decoder<'de>,
4338 {
4339 fn decode(
4340 slot_: ::fidl_next::Slot<'_, Self>,
4341 decoder_: &mut ___D,
4342 _: (),
4343 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4344 ::fidl_next::munge! {
4345 let Self {
4346 mut relative_moniker,
4347
4348 } = slot_;
4349 }
4350
4351 let _field = relative_moniker.as_mut();
4352 ::fidl_next::Constrained::validate(_field, 4096)?;
4353 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
4354
4355 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
4356
4357 if relative_moniker.len() > 4096 {
4358 return Err(::fidl_next::DecodeError::VectorTooLong {
4359 size: relative_moniker.len() as u64,
4360 limit: 4096,
4361 });
4362 }
4363
4364 Ok(())
4365 }
4366 }
4367
4368 impl<'de> ::fidl_next::IntoNatural for StorageAdminDeleteComponentStorageRequest<'de> {
4369 type Natural = crate::natural::StorageAdminDeleteComponentStorageRequest;
4370 }
4371
4372 pub type StorageAdminDeleteComponentStorageResponse = ::fidl_next::wire::Unit;
4374
4375 #[repr(C)]
4377 pub struct StorageStatus<'de> {
4378 pub(crate) table: ::fidl_next::wire::Table<'de>,
4379 }
4380
4381 impl<'de> Drop for StorageStatus<'de> {
4382 fn drop(&mut self) {
4383 let _ = self
4384 .table
4385 .get(1)
4386 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4387
4388 let _ = self
4389 .table
4390 .get(2)
4391 .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::wire::Uint64>() });
4392 }
4393 }
4394
4395 impl ::fidl_next::Constrained for StorageStatus<'_> {
4396 type Constraint = ();
4397
4398 fn validate(
4399 _: ::fidl_next::Slot<'_, Self>,
4400 _: Self::Constraint,
4401 ) -> Result<(), ::fidl_next::ValidationError> {
4402 Ok(())
4403 }
4404 }
4405
4406 unsafe impl ::fidl_next::Wire for StorageStatus<'static> {
4407 type Narrowed<'de> = StorageStatus<'de>;
4408
4409 #[inline]
4410 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4411 ::fidl_next::munge!(let Self { table } = out);
4412 ::fidl_next::wire::Table::zero_padding(table);
4413 }
4414 }
4415
4416 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageStatus<'de>
4417 where
4418 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4419 {
4420 fn decode(
4421 slot: ::fidl_next::Slot<'_, Self>,
4422 decoder: &mut ___D,
4423 _: (),
4424 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4425 ::fidl_next::munge!(let Self { table } = slot);
4426
4427 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4428 match ordinal {
4429 0 => unsafe { ::core::hint::unreachable_unchecked() },
4430
4431 1 => {
4432 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4433 slot.as_mut(),
4434 decoder,
4435 (),
4436 )?;
4437
4438 Ok(())
4439 }
4440
4441 2 => {
4442 ::fidl_next::wire::Envelope::decode_as::<___D, ::fidl_next::wire::Uint64>(
4443 slot.as_mut(),
4444 decoder,
4445 (),
4446 )?;
4447
4448 Ok(())
4449 }
4450
4451 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4452 }
4453 })
4454 }
4455 }
4456
4457 impl<'de> StorageStatus<'de> {
4458 pub fn total_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4459 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4460 }
4461
4462 pub fn used_size(&self) -> ::core::option::Option<&::fidl_next::wire::Uint64> {
4463 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4464 }
4465 }
4466
4467 impl<'de> ::core::fmt::Debug for StorageStatus<'de> {
4468 fn fmt(
4469 &self,
4470 f: &mut ::core::fmt::Formatter<'_>,
4471 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4472 f.debug_struct("StorageStatus")
4473 .field("total_size", &self.total_size())
4474 .field("used_size", &self.used_size())
4475 .finish()
4476 }
4477 }
4478
4479 impl<'de> ::fidl_next::IntoNatural for StorageStatus<'de> {
4480 type Natural = crate::natural::StorageStatus;
4481 }
4482
4483 pub type StorageAdminDeleteAllStorageContentsResponse = ::fidl_next::wire::Unit;
4485
4486 #[derive(Debug)]
4488 #[repr(C)]
4489 pub struct StorageIteratorNextResponse<'de> {
4490 pub relative_monikers: ::fidl_next::wire::Vector<'de, ::fidl_next::wire::String<'de>>,
4491 }
4492
4493 static_assertions::const_assert_eq!(std::mem::size_of::<StorageIteratorNextResponse<'_>>(), 16);
4494 static_assertions::const_assert_eq!(std::mem::align_of::<StorageIteratorNextResponse<'_>>(), 8);
4495
4496 static_assertions::const_assert_eq!(
4497 std::mem::offset_of!(StorageIteratorNextResponse<'_>, relative_monikers),
4498 0
4499 );
4500
4501 impl ::fidl_next::Constrained for StorageIteratorNextResponse<'_> {
4502 type Constraint = ();
4503
4504 fn validate(
4505 _: ::fidl_next::Slot<'_, Self>,
4506 _: Self::Constraint,
4507 ) -> Result<(), ::fidl_next::ValidationError> {
4508 Ok(())
4509 }
4510 }
4511
4512 unsafe impl ::fidl_next::Wire for StorageIteratorNextResponse<'static> {
4513 type Narrowed<'de> = StorageIteratorNextResponse<'de>;
4514
4515 #[inline]
4516 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4517 ::fidl_next::munge! {
4518 let Self {
4519 relative_monikers,
4520
4521 } = &mut *out_;
4522 }
4523
4524 ::fidl_next::Wire::zero_padding(relative_monikers);
4525 }
4526 }
4527
4528 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageIteratorNextResponse<'de>
4529 where
4530 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4531 ___D: ::fidl_next::Decoder<'de>,
4532 {
4533 fn decode(
4534 slot_: ::fidl_next::Slot<'_, Self>,
4535 decoder_: &mut ___D,
4536 _: (),
4537 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4538 ::fidl_next::munge! {
4539 let Self {
4540 mut relative_monikers,
4541
4542 } = slot_;
4543 }
4544
4545 let _field = relative_monikers.as_mut();
4546 ::fidl_next::Constrained::validate(_field, (4294967295, 4096))?;
4547 ::fidl_next::Decode::decode(relative_monikers.as_mut(), decoder_, (4294967295, 4096))?;
4548
4549 Ok(())
4550 }
4551 }
4552
4553 impl<'de> ::fidl_next::IntoNatural for StorageIteratorNextResponse<'de> {
4554 type Natural = crate::natural::StorageIteratorNextResponse;
4555 }
4556
4557 pub type ChildName<'de> = ::fidl_next::wire::String<'de>;
4559
4560 pub type UrlScheme<'de> = ::fidl_next::wire::String<'de>;
4562}
4563
4564pub mod wire_optional {}
4565
4566pub mod generic {
4567
4568 pub struct ChildIteratorNextResponse<T0> {
4570 pub children: T0,
4571 }
4572
4573 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ChildIteratorNextResponse<'static>, ___E>
4574 for ChildIteratorNextResponse<T0>
4575 where
4576 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4577 ___E: ::fidl_next::Encoder,
4578 T0: ::fidl_next::Encode<
4579 ::fidl_next::wire::Vector<
4580 'static,
4581 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4582 >,
4583 ___E,
4584 >,
4585 {
4586 #[inline]
4587 fn encode(
4588 self,
4589 encoder_: &mut ___E,
4590 out_: &mut ::core::mem::MaybeUninit<crate::wire::ChildIteratorNextResponse<'static>>,
4591 _: (),
4592 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4593 ::fidl_next::munge! {
4594 let crate::wire::ChildIteratorNextResponse {
4595 children,
4596
4597 } = out_;
4598 }
4599
4600 ::fidl_next::Encode::encode(self.children, encoder_, children, (128, ()))?;
4601
4602 Ok(())
4603 }
4604 }
4605
4606 pub type ControllerStartResponse = ();
4608
4609 pub type ControllerOpenExposedDirResponse = ();
4611
4612 pub type ControllerDestroyResponse = ();
4614
4615 pub struct ExecutionControllerOnStopRequest<T0> {
4617 pub stopped_payload: T0,
4618 }
4619
4620 unsafe impl<___E, T0>
4621 ::fidl_next::Encode<crate::wire::ExecutionControllerOnStopRequest<'static>, ___E>
4622 for ExecutionControllerOnStopRequest<T0>
4623 where
4624 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4625 ___E: ::fidl_next::Encoder,
4626 T0: ::fidl_next::Encode<crate::wire::StoppedPayload<'static>, ___E>,
4627 {
4628 #[inline]
4629 fn encode(
4630 self,
4631 encoder_: &mut ___E,
4632 out_: &mut ::core::mem::MaybeUninit<
4633 crate::wire::ExecutionControllerOnStopRequest<'static>,
4634 >,
4635 _: (),
4636 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4637 ::fidl_next::munge! {
4638 let crate::wire::ExecutionControllerOnStopRequest {
4639 stopped_payload,
4640
4641 } = out_;
4642 }
4643
4644 ::fidl_next::Encode::encode(self.stopped_payload, encoder_, stopped_payload, ())?;
4645
4646 Ok(())
4647 }
4648 }
4649
4650 pub struct IntrospectorGetMonikerResponse<T0> {
4652 pub moniker: T0,
4653 }
4654
4655 unsafe impl<___E, T0>
4656 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerResponse<'static>, ___E>
4657 for IntrospectorGetMonikerResponse<T0>
4658 where
4659 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4660 ___E: ::fidl_next::Encoder,
4661 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4662 {
4663 #[inline]
4664 fn encode(
4665 self,
4666 encoder_: &mut ___E,
4667 out_: &mut ::core::mem::MaybeUninit<
4668 crate::wire::IntrospectorGetMonikerResponse<'static>,
4669 >,
4670 _: (),
4671 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4672 ::fidl_next::munge! {
4673 let crate::wire::IntrospectorGetMonikerResponse {
4674 moniker,
4675
4676 } = out_;
4677 }
4678
4679 ::fidl_next::Encode::encode(self.moniker, encoder_, moniker, 4096)?;
4680
4681 Ok(())
4682 }
4683 }
4684
4685 pub type RealmOpenExposedDirResponse = ();
4687
4688 pub type RealmCreateChildResponse = ();
4690
4691 pub struct RealmDestroyChildRequest<T0> {
4693 pub child: T0,
4694 }
4695
4696 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::RealmDestroyChildRequest<'static>, ___E>
4697 for RealmDestroyChildRequest<T0>
4698 where
4699 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4700 ___E: ::fidl_next::Encoder,
4701 T0: ::fidl_next::Encode<
4702 ::fidl_next_common_fuchsia_component_decl::wire::ChildRef<'static>,
4703 ___E,
4704 >,
4705 {
4706 #[inline]
4707 fn encode(
4708 self,
4709 encoder_: &mut ___E,
4710 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmDestroyChildRequest<'static>>,
4711 _: (),
4712 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4713 ::fidl_next::munge! {
4714 let crate::wire::RealmDestroyChildRequest {
4715 child,
4716
4717 } = out_;
4718 }
4719
4720 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
4721
4722 Ok(())
4723 }
4724 }
4725
4726 pub type RealmDestroyChildResponse = ();
4728
4729 pub type RealmListChildrenResponse = ();
4731
4732 pub type RealmOpenControllerResponse = ();
4734
4735 pub type StorageAdminOpenStorageResponse = ();
4737
4738 pub type StorageAdminListStorageInRealmResponse = ();
4740
4741 pub type StorageAdminOpenComponentStorageByIdResponse = ();
4743
4744 pub struct StorageAdminDeleteComponentStorageRequest<T0> {
4746 pub relative_moniker: T0,
4747 }
4748
4749 unsafe impl<___E, T0>
4750 ::fidl_next::Encode<crate::wire::StorageAdminDeleteComponentStorageRequest<'static>, ___E>
4751 for StorageAdminDeleteComponentStorageRequest<T0>
4752 where
4753 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4754 ___E: ::fidl_next::Encoder,
4755 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
4756 {
4757 #[inline]
4758 fn encode(
4759 self,
4760 encoder_: &mut ___E,
4761 out_: &mut ::core::mem::MaybeUninit<
4762 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
4763 >,
4764 _: (),
4765 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4766 ::fidl_next::munge! {
4767 let crate::wire::StorageAdminDeleteComponentStorageRequest {
4768 relative_moniker,
4769
4770 } = out_;
4771 }
4772
4773 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
4774
4775 Ok(())
4776 }
4777 }
4778
4779 pub type StorageAdminDeleteComponentStorageResponse = ();
4781
4782 pub type StorageAdminDeleteAllStorageContentsResponse = ();
4784
4785 pub struct StorageIteratorNextResponse<T0> {
4787 pub relative_monikers: T0,
4788 }
4789
4790 unsafe impl<___E, T0>
4791 ::fidl_next::Encode<crate::wire::StorageIteratorNextResponse<'static>, ___E>
4792 for StorageIteratorNextResponse<T0>
4793 where
4794 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
4795 ___E: ::fidl_next::Encoder,
4796 T0: ::fidl_next::Encode<
4797 ::fidl_next::wire::Vector<'static, ::fidl_next::wire::String<'static>>,
4798 ___E,
4799 >,
4800 {
4801 #[inline]
4802 fn encode(
4803 self,
4804 encoder_: &mut ___E,
4805 out_: &mut ::core::mem::MaybeUninit<crate::wire::StorageIteratorNextResponse<'static>>,
4806 _: (),
4807 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
4808 ::fidl_next::munge! {
4809 let crate::wire::StorageIteratorNextResponse {
4810 relative_monikers,
4811
4812 } = out_;
4813 }
4814
4815 ::fidl_next::Encode::encode(
4816 self.relative_monikers,
4817 encoder_,
4818 relative_monikers,
4819 (4294967295, 4096),
4820 )?;
4821
4822 Ok(())
4823 }
4824 }
4825}
4826
4827pub use self::natural::*;
4828
4829#[doc = " A framework-provided protocol that allows components that use it to bind to\n the component that exposes it. The act of connecting to this protocol will\n trigger the bind. Thus, this protocol contains no methods. For more details\n on binding, see\n https://fuchsia.dev/fuchsia-src/concepts/components/v2/lifecycle#binding.\n\n When a component connects to protocol, the component exposing this capability\n will be started if it\'s not already running. Upon a failure to start, the\n component framework will close the server end of the channel with a\n zx.Status epitaph.\n"]
4831#[derive(PartialEq, Debug)]
4832pub struct Binder;
4833
4834impl ::fidl_next::Discoverable for Binder {
4835 const PROTOCOL_NAME: &'static str = "fuchsia.component.Binder";
4836}
4837
4838#[cfg(target_os = "fuchsia")]
4839impl ::fidl_next::HasTransport for Binder {
4840 type Transport = ::fidl_next::fuchsia::zx::Channel;
4841}
4842
4843pub mod binder {
4844 pub mod prelude {
4845 pub use crate::{
4846 Binder, BinderClientHandler, BinderLocalClientHandler, BinderLocalServerHandler,
4847 BinderServerHandler, binder,
4848 };
4849 }
4850
4851 mod ___detail {
4852 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Binder
4853 where
4854 ___T: ::fidl_next::Transport,
4855 {
4856 type Client = BinderClient<___T>;
4857 type Server = BinderServer<___T>;
4858 }
4859
4860 #[repr(transparent)]
4862 pub struct BinderClient<___T: ::fidl_next::Transport> {
4863 #[allow(dead_code)]
4864 client: ::fidl_next::protocol::Client<___T>,
4865 }
4866
4867 impl<___T> BinderClient<___T> where ___T: ::fidl_next::Transport {}
4868
4869 #[repr(transparent)]
4871 pub struct BinderServer<___T: ::fidl_next::Transport> {
4872 server: ::fidl_next::protocol::Server<___T>,
4873 }
4874
4875 impl<___T> BinderServer<___T> where ___T: ::fidl_next::Transport {}
4876 }
4877}
4878
4879#[diagnostic::on_unimplemented(
4880 note = "If {Self} implements the non-local BinderClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
4881)]
4882
4883pub trait BinderLocalClientHandler<
4887 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4888 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4889>
4890{
4891}
4892
4893impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Binder
4894where
4895 ___H: BinderLocalClientHandler<___T>,
4896 ___T: ::fidl_next::Transport,
4897{
4898 async fn on_event(
4899 handler: &mut ___H,
4900 ordinal: u64,
4901 flexibility: ::fidl_next::protocol::Flexibility,
4902 body: ::fidl_next::Body<___T>,
4903 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4904 match ordinal {
4905 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4906 }
4907 }
4908}
4909
4910#[diagnostic::on_unimplemented(
4911 note = "If {Self} implements the non-local BinderServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
4912)]
4913
4914pub trait BinderLocalServerHandler<
4918 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4919 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4920>
4921{
4922}
4923
4924impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Binder
4925where
4926 ___H: BinderLocalServerHandler<___T>,
4927 ___T: ::fidl_next::Transport,
4928{
4929 async fn on_one_way(
4930 handler: &mut ___H,
4931 ordinal: u64,
4932 flexibility: ::fidl_next::protocol::Flexibility,
4933 body: ::fidl_next::Body<___T>,
4934 ) -> ::core::result::Result<
4935 (),
4936 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4937 > {
4938 match ordinal {
4939 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4940 }
4941 }
4942
4943 async fn on_two_way(
4944 handler: &mut ___H,
4945 ordinal: u64,
4946 flexibility: ::fidl_next::protocol::Flexibility,
4947 body: ::fidl_next::Body<___T>,
4948 responder: ::fidl_next::protocol::Responder<___T>,
4949 ) -> ::core::result::Result<
4950 (),
4951 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
4952 > {
4953 match ordinal {
4954 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4955 }
4956 }
4957}
4958
4959pub trait BinderClientHandler<
4963 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4964 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4965>
4966{
4967}
4968
4969impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Binder
4970where
4971 ___H: BinderClientHandler<___T> + ::core::marker::Send,
4972 ___T: ::fidl_next::Transport,
4973{
4974 async fn on_event(
4975 handler: &mut ___H,
4976 ordinal: u64,
4977 flexibility: ::fidl_next::protocol::Flexibility,
4978 body: ::fidl_next::Body<___T>,
4979 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
4980 match ordinal {
4981 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
4982 }
4983 }
4984}
4985
4986pub trait BinderServerHandler<
4990 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
4991 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
4992>
4993{
4994}
4995
4996impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Binder
4997where
4998 ___H: BinderServerHandler<___T> + ::core::marker::Send,
4999 ___T: ::fidl_next::Transport,
5000{
5001 async fn on_one_way(
5002 handler: &mut ___H,
5003 ordinal: u64,
5004 flexibility: ::fidl_next::protocol::Flexibility,
5005 body: ::fidl_next::Body<___T>,
5006 ) -> ::core::result::Result<
5007 (),
5008 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5009 > {
5010 match ordinal {
5011 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5012 }
5013 }
5014
5015 async fn on_two_way(
5016 handler: &mut ___H,
5017 ordinal: u64,
5018 flexibility: ::fidl_next::protocol::Flexibility,
5019 body: ::fidl_next::Body<___T>,
5020 responder: ::fidl_next::protocol::Responder<___T>,
5021 ) -> ::core::result::Result<
5022 (),
5023 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5024 > {
5025 match ordinal {
5026 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5027 }
5028 }
5029}
5030
5031impl<___T> BinderClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport
5032{}
5033
5034impl<___H, ___T> BinderLocalClientHandler<___T> for ::fidl_next::Local<___H>
5035where
5036 ___H: BinderClientHandler<___T>,
5037 ___T: ::fidl_next::Transport,
5038{
5039}
5040
5041impl<___H, ___T> BinderLocalServerHandler<___T> for ::fidl_next::Local<___H>
5042where
5043 ___H: BinderServerHandler<___T>,
5044 ___T: ::fidl_next::Transport,
5045{
5046}
5047
5048pub const MAX_NAME_LENGTH: u64 = 255 as u64;
5049
5050#[doc = " The maximum number of children that the a call `ChildIterator.Next`\n can return.\n Note, this is not a limit on the number of children that can be added\n to a component. This is merely a limit for a single invocation of the\n `Next` method.\n"]
5051pub const MAX_CHILD_COUNT: u32 = 128 as u32;
5052
5053#[doc = " A protocol to iterate over the list of children in a realm.\n"]
5055#[derive(PartialEq, Debug)]
5056pub struct ChildIterator;
5057
5058#[cfg(target_os = "fuchsia")]
5059impl ::fidl_next::HasTransport for ChildIterator {
5060 type Transport = ::fidl_next::fuchsia::zx::Channel;
5061}
5062
5063pub mod child_iterator {
5064 pub mod prelude {
5065 pub use crate::{
5066 ChildIterator, ChildIteratorClientHandler, ChildIteratorLocalClientHandler,
5067 ChildIteratorLocalServerHandler, ChildIteratorServerHandler, child_iterator,
5068 };
5069
5070 pub use crate::natural::ChildIteratorNextResponse;
5071 }
5072
5073 pub struct Next;
5074
5075 impl ::fidl_next::Method for Next {
5076 const ORDINAL: u64 = 4676077302722137352;
5077 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5078 ::fidl_next::protocol::Flexibility::Strict;
5079
5080 type Protocol = crate::ChildIterator;
5081
5082 type Request = ::fidl_next::wire::EmptyMessageBody;
5083 }
5084
5085 impl ::fidl_next::TwoWayMethod for Next {
5086 type Response = crate::wire::ChildIteratorNextResponse<'static>;
5087 }
5088
5089 impl<___R> ::fidl_next::Respond<___R> for Next {
5090 type Output = crate::generic::ChildIteratorNextResponse<___R>;
5091
5092 fn respond(response: ___R) -> Self::Output {
5093 crate::generic::ChildIteratorNextResponse { children: response }
5094 }
5095 }
5096
5097 mod ___detail {
5098 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ChildIterator
5099 where
5100 ___T: ::fidl_next::Transport,
5101 {
5102 type Client = ChildIteratorClient<___T>;
5103 type Server = ChildIteratorServer<___T>;
5104 }
5105
5106 #[repr(transparent)]
5108 pub struct ChildIteratorClient<___T: ::fidl_next::Transport> {
5109 #[allow(dead_code)]
5110 client: ::fidl_next::protocol::Client<___T>,
5111 }
5112
5113 impl<___T> ChildIteratorClient<___T>
5114 where
5115 ___T: ::fidl_next::Transport,
5116 {
5117 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5118 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5119 ::fidl_next::TwoWayFuture::from_untyped(
5120 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5121 4676077302722137352,
5122 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5123 (),
5124 ),
5125 )
5126 }
5127 }
5128
5129 #[repr(transparent)]
5131 pub struct ChildIteratorServer<___T: ::fidl_next::Transport> {
5132 server: ::fidl_next::protocol::Server<___T>,
5133 }
5134
5135 impl<___T> ChildIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5136 }
5137}
5138
5139#[diagnostic::on_unimplemented(
5140 note = "If {Self} implements the non-local ChildIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5141)]
5142
5143pub trait ChildIteratorLocalClientHandler<
5147 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5148 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5149>
5150{
5151}
5152
5153impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ChildIterator
5154where
5155 ___H: ChildIteratorLocalClientHandler<___T>,
5156 ___T: ::fidl_next::Transport,
5157{
5158 async fn on_event(
5159 handler: &mut ___H,
5160 ordinal: u64,
5161 flexibility: ::fidl_next::protocol::Flexibility,
5162 body: ::fidl_next::Body<___T>,
5163 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5164 match ordinal {
5165 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5166 }
5167 }
5168}
5169
5170#[diagnostic::on_unimplemented(
5171 note = "If {Self} implements the non-local ChildIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5172)]
5173
5174pub trait ChildIteratorLocalServerHandler<
5178 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5179 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5180>
5181{
5182 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5183 fn next(
5184 &mut self,
5185
5186 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5187 ) -> impl ::core::future::Future<Output = ()>;
5188}
5189
5190impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ChildIterator
5191where
5192 ___H: ChildIteratorLocalServerHandler<___T>,
5193 ___T: ::fidl_next::Transport,
5194{
5195 async fn on_one_way(
5196 handler: &mut ___H,
5197 ordinal: u64,
5198 flexibility: ::fidl_next::protocol::Flexibility,
5199 body: ::fidl_next::Body<___T>,
5200 ) -> ::core::result::Result<
5201 (),
5202 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5203 > {
5204 match ordinal {
5205 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5206 }
5207 }
5208
5209 async fn on_two_way(
5210 handler: &mut ___H,
5211 ordinal: u64,
5212 flexibility: ::fidl_next::protocol::Flexibility,
5213 body: ::fidl_next::Body<___T>,
5214 responder: ::fidl_next::protocol::Responder<___T>,
5215 ) -> ::core::result::Result<
5216 (),
5217 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5218 > {
5219 match ordinal {
5220 4676077302722137352 => {
5221 let responder = ::fidl_next::Responder::from_untyped(responder);
5222
5223 handler.next(responder).await;
5224 Ok(())
5225 }
5226
5227 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5228 }
5229 }
5230}
5231
5232pub trait ChildIteratorClientHandler<
5236 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5237 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5238>
5239{
5240}
5241
5242impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ChildIterator
5243where
5244 ___H: ChildIteratorClientHandler<___T> + ::core::marker::Send,
5245 ___T: ::fidl_next::Transport,
5246{
5247 async fn on_event(
5248 handler: &mut ___H,
5249 ordinal: u64,
5250 flexibility: ::fidl_next::protocol::Flexibility,
5251 body: ::fidl_next::Body<___T>,
5252 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5253 match ordinal {
5254 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5255 }
5256 }
5257}
5258
5259pub trait ChildIteratorServerHandler<
5263 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5264 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5265>
5266{
5267 #[doc = " Advance the iterator and return the next batch of children.\n\n Returns a vector of `ChildRef`. Returns an empty vector when there are\n no more children.\n"]
5268 fn next(
5269 &mut self,
5270
5271 responder: ::fidl_next::Responder<child_iterator::Next, ___T>,
5272 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5273}
5274
5275impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ChildIterator
5276where
5277 ___H: ChildIteratorServerHandler<___T> + ::core::marker::Send,
5278 ___T: ::fidl_next::Transport,
5279{
5280 async fn on_one_way(
5281 handler: &mut ___H,
5282 ordinal: u64,
5283 flexibility: ::fidl_next::protocol::Flexibility,
5284 body: ::fidl_next::Body<___T>,
5285 ) -> ::core::result::Result<
5286 (),
5287 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5288 > {
5289 match ordinal {
5290 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5291 }
5292 }
5293
5294 async fn on_two_way(
5295 handler: &mut ___H,
5296 ordinal: u64,
5297 flexibility: ::fidl_next::protocol::Flexibility,
5298 body: ::fidl_next::Body<___T>,
5299 responder: ::fidl_next::protocol::Responder<___T>,
5300 ) -> ::core::result::Result<
5301 (),
5302 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5303 > {
5304 match ordinal {
5305 4676077302722137352 => {
5306 let responder = ::fidl_next::Responder::from_untyped(responder);
5307
5308 handler.next(responder).await;
5309 Ok(())
5310 }
5311
5312 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5313 }
5314 }
5315}
5316
5317impl<___T> ChildIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
5318 ___T: ::fidl_next::Transport
5319{
5320}
5321
5322impl<___H, ___T> ChildIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
5323where
5324 ___H: ChildIteratorClientHandler<___T>,
5325 ___T: ::fidl_next::Transport,
5326{
5327}
5328
5329impl<___H, ___T> ChildIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
5330where
5331 ___H: ChildIteratorServerHandler<___T>,
5332 ___T: ::fidl_next::Transport,
5333{
5334 async fn next(&mut self, responder: ::fidl_next::Responder<child_iterator::Next, ___T>) {
5335 ___H::next(&mut self.0, responder).await
5336 }
5337}
5338
5339#[doc = " The maximum number of handles that can be passed to a created component.\n"]
5340pub const MAX_HANDLE_COUNT: u32 = 128 as u32;
5341
5342pub const MAX_NAMESPACE_COUNT: u32 = 32 as u32;
5343
5344pub const MAX_PATH_LENGTH: u64 = 4095 as u64;
5345
5346#[doc = " The maximum number of dynamic offers that can target a created component.\n"]
5347pub const MAX_DYNAMIC_OFFER_COUNT: u32 = 128 as u32;
5348
5349pub const MAX_MONIKER_LENGTH: u32 = 4096 as u32;
5350
5351#[derive(PartialEq, Debug)]
5353pub struct ExecutionController;
5354
5355#[cfg(target_os = "fuchsia")]
5356impl ::fidl_next::HasTransport for ExecutionController {
5357 type Transport = ::fidl_next::fuchsia::zx::Channel;
5358}
5359
5360pub mod execution_controller {
5361 pub mod prelude {
5362 pub use crate::{
5363 ExecutionController, ExecutionControllerClientHandler,
5364 ExecutionControllerLocalClientHandler, ExecutionControllerLocalServerHandler,
5365 ExecutionControllerServerHandler, execution_controller,
5366 };
5367
5368 pub use crate::natural::ExecutionControllerOnStopRequest;
5369 }
5370
5371 pub struct Stop;
5372
5373 impl ::fidl_next::Method for Stop {
5374 const ORDINAL: u64 = 6256129817234858263;
5375 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5376 ::fidl_next::protocol::Flexibility::Flexible;
5377
5378 type Protocol = crate::ExecutionController;
5379
5380 type Request = ::fidl_next::wire::EmptyMessageBody;
5381 }
5382
5383 pub struct OnStop;
5384
5385 impl ::fidl_next::Method for OnStop {
5386 const ORDINAL: u64 = 7121600095714604415;
5387 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5388 ::fidl_next::protocol::Flexibility::Flexible;
5389
5390 type Protocol = crate::ExecutionController;
5391
5392 type Request = crate::wire::ExecutionControllerOnStopRequest<'static>;
5393 }
5394
5395 mod ___detail {
5396 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::ExecutionController
5397 where
5398 ___T: ::fidl_next::Transport,
5399 {
5400 type Client = ExecutionControllerClient<___T>;
5401 type Server = ExecutionControllerServer<___T>;
5402 }
5403
5404 #[repr(transparent)]
5406 pub struct ExecutionControllerClient<___T: ::fidl_next::Transport> {
5407 #[allow(dead_code)]
5408 client: ::fidl_next::protocol::Client<___T>,
5409 }
5410
5411 impl<___T> ExecutionControllerClient<___T>
5412 where
5413 ___T: ::fidl_next::Transport,
5414 {
5415 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5416 pub fn stop(&self) -> ::fidl_next::SendFuture<'_, ___T> {
5417 ::fidl_next::SendFuture::from_untyped(
5418 self.client.send_one_way::<::fidl_next::wire::EmptyMessageBody>(
5419 6256129817234858263,
5420 <super::Stop as ::fidl_next::Method>::FLEXIBILITY,
5421 (),
5422 ),
5423 )
5424 }
5425 }
5426
5427 #[repr(transparent)]
5429 pub struct ExecutionControllerServer<___T: ::fidl_next::Transport> {
5430 server: ::fidl_next::protocol::Server<___T>,
5431 }
5432
5433 impl<___T> ExecutionControllerServer<___T>
5434 where
5435 ___T: ::fidl_next::Transport,
5436 {
5437 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5438 pub fn on_stop(
5439 &self,
5440
5441 stopped_payload: impl ::fidl_next::Encode<
5442 crate::wire::StoppedPayload<'static>,
5443 <___T as ::fidl_next::Transport>::SendBuffer,
5444 >,
5445 ) -> ::fidl_next::SendFuture<'_, ___T>
5446 where
5447 <___T as ::fidl_next::Transport>::SendBuffer:
5448 ::fidl_next::encoder::InternalHandleEncoder,
5449 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
5450 {
5451 self.on_stop_with(crate::generic::ExecutionControllerOnStopRequest {
5452 stopped_payload,
5453 })
5454 }
5455
5456 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5457
5458 pub fn on_stop_with<___R>(&self, request: ___R) -> ::fidl_next::SendFuture<'_, ___T>
5459 where
5460 ___R: ::fidl_next::Encode<
5461 <super::OnStop as ::fidl_next::Method>::Request,
5462 <___T as ::fidl_next::Transport>::SendBuffer,
5463 >,
5464 {
5465 ::fidl_next::SendFuture::from_untyped(self.server.send_event(
5466 7121600095714604415,
5467 <super::OnStop as ::fidl_next::Method>::FLEXIBILITY,
5468 request,
5469 ))
5470 }
5471 }
5472 }
5473}
5474
5475#[diagnostic::on_unimplemented(
5476 note = "If {Self} implements the non-local ExecutionControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5477)]
5478
5479pub trait ExecutionControllerLocalClientHandler<
5483 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5484 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5485>
5486{
5487 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5488 fn on_stop(
5489 &mut self,
5490
5491 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5492 ) -> impl ::core::future::Future<Output = ()>;
5493
5494 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5495 ::core::future::ready(())
5496 }
5497}
5498
5499impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for ExecutionController
5500where
5501 ___H: ExecutionControllerLocalClientHandler<___T>,
5502 ___T: ::fidl_next::Transport,
5503 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5504 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5505 Constraint = (),
5506 >,
5507{
5508 async fn on_event(
5509 handler: &mut ___H,
5510 ordinal: u64,
5511 flexibility: ::fidl_next::protocol::Flexibility,
5512 body: ::fidl_next::Body<___T>,
5513 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5514 match ordinal {
5515 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
5516 Ok(decoded) => {
5517 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5518 Ok(())
5519 }
5520 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5521 ordinal: 7121600095714604415,
5522 error,
5523 }),
5524 },
5525
5526 ordinal => {
5527 handler.on_unknown_interaction(ordinal).await;
5528 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5529 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5530 } else {
5531 Ok(())
5532 }
5533 }
5534 }
5535 }
5536}
5537
5538#[diagnostic::on_unimplemented(
5539 note = "If {Self} implements the non-local ExecutionControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5540)]
5541
5542pub trait ExecutionControllerLocalServerHandler<
5546 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5547 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5548>
5549{
5550 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5551 fn stop(&mut self) -> impl ::core::future::Future<Output = ()>;
5552
5553 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
5554 ::core::future::ready(())
5555 }
5556}
5557
5558impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for ExecutionController
5559where
5560 ___H: ExecutionControllerLocalServerHandler<___T>,
5561 ___T: ::fidl_next::Transport,
5562{
5563 async fn on_one_way(
5564 handler: &mut ___H,
5565 ordinal: u64,
5566 flexibility: ::fidl_next::protocol::Flexibility,
5567 body: ::fidl_next::Body<___T>,
5568 ) -> ::core::result::Result<
5569 (),
5570 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5571 > {
5572 match ordinal {
5573 6256129817234858263 => {
5574 handler.stop().await;
5575 Ok(())
5576 }
5577
5578 ordinal => {
5579 handler.on_unknown_interaction(ordinal).await;
5580 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5581 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5582 } else {
5583 Ok(())
5584 }
5585 }
5586 }
5587 }
5588
5589 async fn on_two_way(
5590 handler: &mut ___H,
5591 ordinal: u64,
5592 flexibility: ::fidl_next::protocol::Flexibility,
5593 body: ::fidl_next::Body<___T>,
5594 responder: ::fidl_next::protocol::Responder<___T>,
5595 ) -> ::core::result::Result<
5596 (),
5597 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5598 > {
5599 match ordinal {
5600 ordinal => {
5601 handler.on_unknown_interaction(ordinal).await;
5602 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5603 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5604 } else {
5605 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5606 ordinal,
5607 flexibility,
5608 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5609 )
5610 .expect("encoding a framework error should never fail")
5611 .await?;
5612 Ok(())
5613 }
5614 }
5615 }
5616 }
5617}
5618
5619pub trait ExecutionControllerClientHandler<
5623 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5624 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5625>
5626{
5627 #[doc = " When the child is stopped due to `Stop` being called, the child exiting\n on its own, or for any other reason, `OnStop` is called and then this\n channel is closed.\n"]
5628 fn on_stop(
5629 &mut self,
5630
5631 request: ::fidl_next::Request<execution_controller::OnStop, ___T>,
5632 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5633
5634 fn on_unknown_interaction(
5635 &mut self,
5636 ordinal: u64,
5637 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5638 ::core::future::ready(())
5639 }
5640}
5641
5642impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for ExecutionController
5643where
5644 ___H: ExecutionControllerClientHandler<___T> + ::core::marker::Send,
5645 ___T: ::fidl_next::Transport,
5646 for<'de> crate::wire::ExecutionControllerOnStopRequest<'de>: ::fidl_next::Decode<
5647 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
5648 Constraint = (),
5649 >,
5650{
5651 async fn on_event(
5652 handler: &mut ___H,
5653 ordinal: u64,
5654 flexibility: ::fidl_next::protocol::Flexibility,
5655 body: ::fidl_next::Body<___T>,
5656 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5657 match ordinal {
5658 7121600095714604415 => match ::fidl_next::AsDecoderExt::into_decoded(body) {
5659 Ok(decoded) => {
5660 handler.on_stop(::fidl_next::Request::from_decoded(decoded)).await;
5661 Ok(())
5662 }
5663 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
5664 ordinal: 7121600095714604415,
5665 error,
5666 }),
5667 },
5668
5669 ordinal => {
5670 handler.on_unknown_interaction(ordinal).await;
5671 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5672 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5673 } else {
5674 Ok(())
5675 }
5676 }
5677 }
5678 }
5679}
5680
5681pub trait ExecutionControllerServerHandler<
5685 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5686 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5687>
5688{
5689 #[doc = " Initiates a stop action on this component. Once complete, OnStop will be\n called with the stopped payload and this channel is closed.\n\n Note that a component may stop running on its own at any time, so it is\n possible for `OnStop` to be received before `Stop` is called.\n"]
5690 fn stop(&mut self) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
5691
5692 fn on_unknown_interaction(
5693 &mut self,
5694 ordinal: u64,
5695 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
5696 ::core::future::ready(())
5697 }
5698}
5699
5700impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for ExecutionController
5701where
5702 ___H: ExecutionControllerServerHandler<___T> + ::core::marker::Send,
5703 ___T: ::fidl_next::Transport,
5704{
5705 async fn on_one_way(
5706 handler: &mut ___H,
5707 ordinal: u64,
5708 flexibility: ::fidl_next::protocol::Flexibility,
5709 body: ::fidl_next::Body<___T>,
5710 ) -> ::core::result::Result<
5711 (),
5712 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5713 > {
5714 match ordinal {
5715 6256129817234858263 => {
5716 handler.stop().await;
5717 Ok(())
5718 }
5719
5720 ordinal => {
5721 handler.on_unknown_interaction(ordinal).await;
5722 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5723 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5724 } else {
5725 Ok(())
5726 }
5727 }
5728 }
5729 }
5730
5731 async fn on_two_way(
5732 handler: &mut ___H,
5733 ordinal: u64,
5734 flexibility: ::fidl_next::protocol::Flexibility,
5735 body: ::fidl_next::Body<___T>,
5736 responder: ::fidl_next::protocol::Responder<___T>,
5737 ) -> ::core::result::Result<
5738 (),
5739 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5740 > {
5741 match ordinal {
5742 ordinal => {
5743 handler.on_unknown_interaction(ordinal).await;
5744 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
5745 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
5746 } else {
5747 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
5748 ordinal,
5749 flexibility,
5750 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
5751 )
5752 .expect("encoding a framework error should never fail")
5753 .await?;
5754 Ok(())
5755 }
5756 }
5757 }
5758 }
5759}
5760
5761impl<___T> ExecutionControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
5762where
5763 ___T: ::fidl_next::Transport,
5764{
5765 async fn on_stop(&mut self, _: ::fidl_next::Request<execution_controller::OnStop, ___T>) {}
5766
5767 async fn on_unknown_interaction(&mut self, _: u64) {}
5768}
5769
5770impl<___H, ___T> ExecutionControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
5771where
5772 ___H: ExecutionControllerClientHandler<___T>,
5773 ___T: ::fidl_next::Transport,
5774{
5775 async fn on_stop(&mut self, request: ::fidl_next::Request<execution_controller::OnStop, ___T>) {
5776 ___H::on_stop(&mut self.0, request).await
5777 }
5778
5779 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5780 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5781 }
5782}
5783
5784impl<___H, ___T> ExecutionControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
5785where
5786 ___H: ExecutionControllerServerHandler<___T>,
5787 ___T: ::fidl_next::Transport,
5788{
5789 async fn stop(&mut self) {
5790 ___H::stop(&mut self.0).await
5791 }
5792
5793 async fn on_unknown_interaction(&mut self, ordinal: u64) {
5794 ___H::on_unknown_interaction(&mut self.0, ordinal).await
5795 }
5796}
5797
5798#[doc = " The maximum string length of a capability ID.\n This value is currently set arbitrarily.\n"]
5799pub const MAX_CAPABILITY_ID_LENGTH: u64 = 50 as u64;
5800
5801pub const MAX_CHILD_NAME_LENGTH: u32 = 1024 as u32;
5802
5803#[doc = " The maximum string length of an error description.\n"]
5804pub const MAX_ERROR_DESCRIPTION_LENGTH: u64 = 100 as u64;
5805
5806#[doc = " The maximum number of events that a receiver can listen to.\n"]
5807pub const MAX_NUM_EVENTS_RECEIVED: u64 = 100 as u64;
5808
5809#[doc = " The maximum length of a storage instance ID.\n A storage instance ID is a 256-bit UUID, which when encoded\n in hex notation is 64 characters long.\n"]
5810pub const MAX_STORAGE_ID_LENGTH: u32 = 64 as u32;
5811
5812#[doc = " The maximum number of requests per event subscription.\n"]
5813pub const MAX_SUBSCRIPTION_REQUESTS: u32 = 2 as u32;
5814
5815pub const MAX_URL_SCHEME_LENGTH: u64 = 255 as u64;
5816
5817#[doc = " An iterator protocol for returning a set of components using a storage\n capability. See |StorageAdmin.ListStorageInRealm| for more information.\n"]
5819#[derive(PartialEq, Debug)]
5820pub struct StorageIterator;
5821
5822#[cfg(target_os = "fuchsia")]
5823impl ::fidl_next::HasTransport for StorageIterator {
5824 type Transport = ::fidl_next::fuchsia::zx::Channel;
5825}
5826
5827pub mod storage_iterator {
5828 pub mod prelude {
5829 pub use crate::{
5830 StorageIterator, StorageIteratorClientHandler, StorageIteratorLocalClientHandler,
5831 StorageIteratorLocalServerHandler, StorageIteratorServerHandler, storage_iterator,
5832 };
5833
5834 pub use crate::natural::StorageIteratorNextResponse;
5835 }
5836
5837 pub struct Next;
5838
5839 impl ::fidl_next::Method for Next {
5840 const ORDINAL: u64 = 8821181615713557362;
5841 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
5842 ::fidl_next::protocol::Flexibility::Strict;
5843
5844 type Protocol = crate::StorageIterator;
5845
5846 type Request = ::fidl_next::wire::EmptyMessageBody;
5847 }
5848
5849 impl ::fidl_next::TwoWayMethod for Next {
5850 type Response = crate::wire::StorageIteratorNextResponse<'static>;
5851 }
5852
5853 impl<___R> ::fidl_next::Respond<___R> for Next {
5854 type Output = crate::generic::StorageIteratorNextResponse<___R>;
5855
5856 fn respond(response: ___R) -> Self::Output {
5857 crate::generic::StorageIteratorNextResponse { relative_monikers: response }
5858 }
5859 }
5860
5861 mod ___detail {
5862 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageIterator
5863 where
5864 ___T: ::fidl_next::Transport,
5865 {
5866 type Client = StorageIteratorClient<___T>;
5867 type Server = StorageIteratorServer<___T>;
5868 }
5869
5870 #[repr(transparent)]
5872 pub struct StorageIteratorClient<___T: ::fidl_next::Transport> {
5873 #[allow(dead_code)]
5874 client: ::fidl_next::protocol::Client<___T>,
5875 }
5876
5877 impl<___T> StorageIteratorClient<___T>
5878 where
5879 ___T: ::fidl_next::Transport,
5880 {
5881 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
5882 pub fn next(&self) -> ::fidl_next::TwoWayFuture<'_, super::Next, ___T> {
5883 ::fidl_next::TwoWayFuture::from_untyped(
5884 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
5885 8821181615713557362,
5886 <super::Next as ::fidl_next::Method>::FLEXIBILITY,
5887 (),
5888 ),
5889 )
5890 }
5891 }
5892
5893 #[repr(transparent)]
5895 pub struct StorageIteratorServer<___T: ::fidl_next::Transport> {
5896 server: ::fidl_next::protocol::Server<___T>,
5897 }
5898
5899 impl<___T> StorageIteratorServer<___T> where ___T: ::fidl_next::Transport {}
5900 }
5901}
5902
5903#[diagnostic::on_unimplemented(
5904 note = "If {Self} implements the non-local StorageIteratorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
5905)]
5906
5907pub trait StorageIteratorLocalClientHandler<
5911 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5912 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5913>
5914{
5915}
5916
5917impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageIterator
5918where
5919 ___H: StorageIteratorLocalClientHandler<___T>,
5920 ___T: ::fidl_next::Transport,
5921{
5922 async fn on_event(
5923 handler: &mut ___H,
5924 ordinal: u64,
5925 flexibility: ::fidl_next::protocol::Flexibility,
5926 body: ::fidl_next::Body<___T>,
5927 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
5928 match ordinal {
5929 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5930 }
5931 }
5932}
5933
5934#[diagnostic::on_unimplemented(
5935 note = "If {Self} implements the non-local StorageIteratorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
5936)]
5937
5938pub trait StorageIteratorLocalServerHandler<
5942 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
5943 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
5944>
5945{
5946 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
5947 fn next(
5948 &mut self,
5949
5950 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
5951 ) -> impl ::core::future::Future<Output = ()>;
5952}
5953
5954impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageIterator
5955where
5956 ___H: StorageIteratorLocalServerHandler<___T>,
5957 ___T: ::fidl_next::Transport,
5958{
5959 async fn on_one_way(
5960 handler: &mut ___H,
5961 ordinal: u64,
5962 flexibility: ::fidl_next::protocol::Flexibility,
5963 body: ::fidl_next::Body<___T>,
5964 ) -> ::core::result::Result<
5965 (),
5966 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5967 > {
5968 match ordinal {
5969 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5970 }
5971 }
5972
5973 async fn on_two_way(
5974 handler: &mut ___H,
5975 ordinal: u64,
5976 flexibility: ::fidl_next::protocol::Flexibility,
5977 body: ::fidl_next::Body<___T>,
5978 responder: ::fidl_next::protocol::Responder<___T>,
5979 ) -> ::core::result::Result<
5980 (),
5981 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
5982 > {
5983 match ordinal {
5984 8821181615713557362 => {
5985 let responder = ::fidl_next::Responder::from_untyped(responder);
5986
5987 handler.next(responder).await;
5988 Ok(())
5989 }
5990
5991 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
5992 }
5993 }
5994}
5995
5996pub trait StorageIteratorClientHandler<
6000 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6001 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6002>
6003{
6004}
6005
6006impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageIterator
6007where
6008 ___H: StorageIteratorClientHandler<___T> + ::core::marker::Send,
6009 ___T: ::fidl_next::Transport,
6010{
6011 async fn on_event(
6012 handler: &mut ___H,
6013 ordinal: u64,
6014 flexibility: ::fidl_next::protocol::Flexibility,
6015 body: ::fidl_next::Body<___T>,
6016 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
6017 match ordinal {
6018 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6019 }
6020 }
6021}
6022
6023pub trait StorageIteratorServerHandler<
6027 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
6028 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
6029>
6030{
6031 #[doc = " Retrieve the next set of components using the storage capability. The\n returned monikers are relative to the component that declares the\n storage capability. Returns an empty vector after all components have\n been returned.\n"]
6032 fn next(
6033 &mut self,
6034
6035 responder: ::fidl_next::Responder<storage_iterator::Next, ___T>,
6036 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
6037}
6038
6039impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageIterator
6040where
6041 ___H: StorageIteratorServerHandler<___T> + ::core::marker::Send,
6042 ___T: ::fidl_next::Transport,
6043{
6044 async fn on_one_way(
6045 handler: &mut ___H,
6046 ordinal: u64,
6047 flexibility: ::fidl_next::protocol::Flexibility,
6048 body: ::fidl_next::Body<___T>,
6049 ) -> ::core::result::Result<
6050 (),
6051 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6052 > {
6053 match ordinal {
6054 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6055 }
6056 }
6057
6058 async fn on_two_way(
6059 handler: &mut ___H,
6060 ordinal: u64,
6061 flexibility: ::fidl_next::protocol::Flexibility,
6062 body: ::fidl_next::Body<___T>,
6063 responder: ::fidl_next::protocol::Responder<___T>,
6064 ) -> ::core::result::Result<
6065 (),
6066 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
6067 > {
6068 match ordinal {
6069 8821181615713557362 => {
6070 let responder = ::fidl_next::Responder::from_untyped(responder);
6071
6072 handler.next(responder).await;
6073 Ok(())
6074 }
6075
6076 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
6077 }
6078 }
6079}
6080
6081impl<___T> StorageIteratorClientHandler<___T> for ::fidl_next::IgnoreEvents where
6082 ___T: ::fidl_next::Transport
6083{
6084}
6085
6086impl<___H, ___T> StorageIteratorLocalClientHandler<___T> for ::fidl_next::Local<___H>
6087where
6088 ___H: StorageIteratorClientHandler<___T>,
6089 ___T: ::fidl_next::Transport,
6090{
6091}
6092
6093impl<___H, ___T> StorageIteratorLocalServerHandler<___T> for ::fidl_next::Local<___H>
6094where
6095 ___H: StorageIteratorServerHandler<___T>,
6096 ___T: ::fidl_next::Transport,
6097{
6098 async fn next(&mut self, responder: ::fidl_next::Responder<storage_iterator::Next, ___T>) {
6099 ___H::next(&mut self.0, responder).await
6100 }
6101}