1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_component::natural::*;
8
9 #[doc = " Payload for CapabilityRequested events\n"]
10 #[derive(Debug, Default, PartialEq)]
11 pub struct CapabilityRequestedPayload {
12 pub name: ::core::option::Option<::std::string::String>,
13
14 pub capability: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
15 }
16
17 impl CapabilityRequestedPayload {
18 fn __max_ordinal(&self) -> usize {
19 if self.capability.is_some() {
20 return 2;
21 }
22
23 if self.name.is_some() {
24 return 1;
25 }
26
27 0
28 }
29 }
30
31 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityRequestedPayload<'static>, ___E>
32 for CapabilityRequestedPayload
33 where
34 ___E: ::fidl_next::Encoder + ?Sized,
35 ___E: ::fidl_next::fuchsia::HandleEncoder,
36 {
37 #[inline]
38 fn encode(
39 mut self,
40 encoder: &mut ___E,
41 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRequestedPayload<'static>>,
42 _: (),
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::munge!(let crate::wire::CapabilityRequestedPayload { table } = out);
45
46 let max_ord = self.__max_ordinal();
47
48 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
49 ::fidl_next::Wire::zero_padding(&mut out);
50
51 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
52 ::fidl_next::wire::Envelope,
53 >(encoder, max_ord);
54
55 for i in 1..=max_ord {
56 match i {
57 2 => {
58 if let Some(value) = self.capability.take() {
59 ::fidl_next::wire::Envelope::encode_value::<
60 ::fidl_next::wire::fuchsia::Channel,
61 ___E,
62 >(
63 value, preallocated.encoder, &mut out, ()
64 )?;
65 } else {
66 ::fidl_next::wire::Envelope::encode_zero(&mut out)
67 }
68 }
69
70 1 => {
71 if let Some(value) = self.name.take() {
72 ::fidl_next::wire::Envelope::encode_value::<
73 ::fidl_next::wire::String<'static>,
74 ___E,
75 >(
76 value, preallocated.encoder, &mut out, 255
77 )?;
78 } else {
79 ::fidl_next::wire::Envelope::encode_zero(&mut out)
80 }
81 }
82
83 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
84 }
85 unsafe {
86 preallocated.write_next(out.assume_init_ref());
87 }
88 }
89
90 ::fidl_next::wire::Table::encode_len(table, max_ord);
91
92 Ok(())
93 }
94 }
95
96 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityRequestedPayload<'de>>
97 for CapabilityRequestedPayload
98 {
99 #[inline]
100 fn from_wire(wire_: crate::wire::CapabilityRequestedPayload<'de>) -> Self {
101 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
102
103 let name = wire_.table.get(1);
104
105 let capability = wire_.table.get(2);
106
107 Self {
108 name: name.map(|envelope| {
109 ::fidl_next::FromWire::from_wire(unsafe {
110 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
111 })
112 }),
113
114 capability: capability.map(|envelope| {
115 ::fidl_next::FromWire::from_wire(unsafe {
116 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
117 })
118 }),
119 }
120 }
121 }
122
123 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
124 #[repr(C)]
125 pub struct ControllerIsStartedResponse {
126 pub is_started: bool,
127 }
128
129 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
130 for ControllerIsStartedResponse
131 where
132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
133 ___E: ::fidl_next::fuchsia::HandleEncoder,
134 {
135 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
136 Self,
137 crate::wire::ControllerIsStartedResponse,
138 > = unsafe {
139 ::fidl_next::CopyOptimization::enable_if(
140 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
141 )
142 };
143
144 #[inline]
145 fn encode(
146 self,
147 encoder_: &mut ___E,
148 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
149 _: (),
150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
151 ::fidl_next::munge! {
152 let crate::wire::ControllerIsStartedResponse {
153 is_started,
154
155 } = out_;
156 }
157
158 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
159
160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_started.as_mut_ptr()) };
161
162 Ok(())
163 }
164 }
165
166 unsafe impl<___E>
167 ::fidl_next::EncodeOption<
168 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
169 ___E,
170 > for ControllerIsStartedResponse
171 where
172 ___E: ::fidl_next::Encoder + ?Sized,
173 ControllerIsStartedResponse:
174 ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>,
175 {
176 #[inline]
177 fn encode_option(
178 this: ::core::option::Option<Self>,
179 encoder: &mut ___E,
180 out: &mut ::core::mem::MaybeUninit<
181 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
182 >,
183 _: (),
184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185 if let Some(inner) = this {
186 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
187 ::fidl_next::wire::Box::encode_present(out);
188 } else {
189 ::fidl_next::wire::Box::encode_absent(out);
190 }
191
192 Ok(())
193 }
194 }
195
196 impl ::fidl_next::FromWire<crate::wire::ControllerIsStartedResponse>
197 for ControllerIsStartedResponse
198 {
199 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
200 crate::wire::ControllerIsStartedResponse,
201 Self,
202 > = unsafe {
203 ::fidl_next::CopyOptimization::enable_if(
204 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
205 )
206 };
207
208 #[inline]
209 fn from_wire(wire: crate::wire::ControllerIsStartedResponse) -> Self {
210 Self { is_started: ::fidl_next::FromWire::from_wire(wire.is_started) }
211 }
212 }
213
214 #[derive(Debug, PartialEq)]
215 #[repr(C)]
216 pub struct ControllerGetExposedDictionaryResponse {
217 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
218 }
219
220 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
221 for ControllerGetExposedDictionaryResponse
222 where
223 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
224 ___E: ::fidl_next::fuchsia::HandleEncoder,
225 {
226 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
227 Self,
228 crate::wire::ControllerGetExposedDictionaryResponse,
229 > = unsafe {
230 ::fidl_next::CopyOptimization::enable_if(
231 true
232
233 && <
234 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
235 >::COPY_OPTIMIZATION.is_enabled()
236
237 )
238 };
239
240 #[inline]
241 fn encode(
242 self,
243 encoder_: &mut ___E,
244 out_: &mut ::core::mem::MaybeUninit<
245 crate::wire::ControllerGetExposedDictionaryResponse,
246 >,
247 _: (),
248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
249 ::fidl_next::munge! {
250 let crate::wire::ControllerGetExposedDictionaryResponse {
251 dictionary,
252
253 } = out_;
254 }
255
256 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
257
258 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
259
260 Ok(())
261 }
262 }
263
264 unsafe impl<___E>
265 ::fidl_next::EncodeOption<
266 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetExposedDictionaryResponse>,
267 ___E,
268 > for ControllerGetExposedDictionaryResponse
269 where
270 ___E: ::fidl_next::Encoder + ?Sized,
271 ControllerGetExposedDictionaryResponse:
272 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>,
273 {
274 #[inline]
275 fn encode_option(
276 this: ::core::option::Option<Self>,
277 encoder: &mut ___E,
278 out: &mut ::core::mem::MaybeUninit<
279 ::fidl_next::wire::Box<
280 'static,
281 crate::wire::ControllerGetExposedDictionaryResponse,
282 >,
283 >,
284 _: (),
285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
286 if let Some(inner) = this {
287 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
288 ::fidl_next::wire::Box::encode_present(out);
289 } else {
290 ::fidl_next::wire::Box::encode_absent(out);
291 }
292
293 Ok(())
294 }
295 }
296
297 impl ::fidl_next::FromWire<crate::wire::ControllerGetExposedDictionaryResponse>
298 for ControllerGetExposedDictionaryResponse
299 {
300 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
301 crate::wire::ControllerGetExposedDictionaryResponse,
302 Self,
303 > = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true
306
307 && <
308 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
309 >::COPY_OPTIMIZATION.is_enabled()
310
311 )
312 };
313
314 #[inline]
315 fn from_wire(wire: crate::wire::ControllerGetExposedDictionaryResponse) -> Self {
316 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
317 }
318 }
319
320 #[derive(Debug, PartialEq)]
321 #[repr(C)]
322 pub struct ControllerGetOutputDictionaryResponse {
323 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
324 }
325
326 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
327 for ControllerGetOutputDictionaryResponse
328 where
329 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
330 ___E: ::fidl_next::fuchsia::HandleEncoder,
331 {
332 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
333 Self,
334 crate::wire::ControllerGetOutputDictionaryResponse,
335 > = unsafe {
336 ::fidl_next::CopyOptimization::enable_if(
337 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
338 ::fidl_next::wire::fuchsia::EventPair,
339 ___E,
340 >>::COPY_OPTIMIZATION
341 .is_enabled(),
342 )
343 };
344
345 #[inline]
346 fn encode(
347 self,
348 encoder_: &mut ___E,
349 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
350 _: (),
351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
352 ::fidl_next::munge! {
353 let crate::wire::ControllerGetOutputDictionaryResponse {
354 dictionary,
355
356 } = out_;
357 }
358
359 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
360
361 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
362
363 Ok(())
364 }
365 }
366
367 unsafe impl<___E>
368 ::fidl_next::EncodeOption<
369 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
370 ___E,
371 > for ControllerGetOutputDictionaryResponse
372 where
373 ___E: ::fidl_next::Encoder + ?Sized,
374 ControllerGetOutputDictionaryResponse:
375 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>,
376 {
377 #[inline]
378 fn encode_option(
379 this: ::core::option::Option<Self>,
380 encoder: &mut ___E,
381 out: &mut ::core::mem::MaybeUninit<
382 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
383 >,
384 _: (),
385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
386 if let Some(inner) = this {
387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
388 ::fidl_next::wire::Box::encode_present(out);
389 } else {
390 ::fidl_next::wire::Box::encode_absent(out);
391 }
392
393 Ok(())
394 }
395 }
396
397 impl ::fidl_next::FromWire<crate::wire::ControllerGetOutputDictionaryResponse>
398 for ControllerGetOutputDictionaryResponse
399 {
400 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
401 crate::wire::ControllerGetOutputDictionaryResponse,
402 Self,
403 > = unsafe {
404 ::fidl_next::CopyOptimization::enable_if(
405 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
406 ::fidl_next::wire::fuchsia::EventPair,
407 >>::COPY_OPTIMIZATION
408 .is_enabled(),
409 )
410 };
411
412 #[inline]
413 fn from_wire(wire: crate::wire::ControllerGetOutputDictionaryResponse) -> Self {
414 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
415 }
416 }
417
418 #[doc = " A single component namespace entry, which describes a namespace mount point\n (`path`) and the directory backing it (`directory`). This type is usually\n composed inside a vector. See `ComponentStartInfo.ns` for more details.\n"]
419 #[derive(Debug, Default, PartialEq)]
420 pub struct NamespaceEntry {
421 pub path: ::core::option::Option<::std::string::String>,
422
423 pub directory: ::core::option::Option<
424 ::fidl_next::ClientEnd<
425 ::fidl_next_fuchsia_io::Directory,
426 ::fidl_next::fuchsia::zx::Channel,
427 >,
428 >,
429 }
430
431 impl NamespaceEntry {
432 fn __max_ordinal(&self) -> usize {
433 if self.directory.is_some() {
434 return 2;
435 }
436
437 if self.path.is_some() {
438 return 1;
439 }
440
441 0
442 }
443 }
444
445 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceEntry<'static>, ___E> for NamespaceEntry
446 where
447 ___E: ::fidl_next::Encoder + ?Sized,
448 ___E: ::fidl_next::fuchsia::HandleEncoder,
449 {
450 #[inline]
451 fn encode(
452 mut self,
453 encoder: &mut ___E,
454 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceEntry<'static>>,
455 _: (),
456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
457 ::fidl_next::munge!(let crate::wire::NamespaceEntry { table } = out);
458
459 let max_ord = self.__max_ordinal();
460
461 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
462 ::fidl_next::Wire::zero_padding(&mut out);
463
464 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
465 ::fidl_next::wire::Envelope,
466 >(encoder, max_ord);
467
468 for i in 1..=max_ord {
469 match i {
470 2 => {
471 if let Some(value) = self.directory.take() {
472 ::fidl_next::wire::Envelope::encode_value::<
473 ::fidl_next::ClientEnd<
474 ::fidl_next_fuchsia_io::Directory,
475 ::fidl_next::wire::fuchsia::Channel,
476 >,
477 ___E,
478 >(
479 value, preallocated.encoder, &mut out, ()
480 )?;
481 } else {
482 ::fidl_next::wire::Envelope::encode_zero(&mut out)
483 }
484 }
485
486 1 => {
487 if let Some(value) = self.path.take() {
488 ::fidl_next::wire::Envelope::encode_value::<
489 ::fidl_next::wire::String<'static>,
490 ___E,
491 >(
492 value, preallocated.encoder, &mut out, 4095
493 )?;
494 } else {
495 ::fidl_next::wire::Envelope::encode_zero(&mut out)
496 }
497 }
498
499 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
500 }
501 unsafe {
502 preallocated.write_next(out.assume_init_ref());
503 }
504 }
505
506 ::fidl_next::wire::Table::encode_len(table, max_ord);
507
508 Ok(())
509 }
510 }
511
512 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceEntry<'de>> for NamespaceEntry {
513 #[inline]
514 fn from_wire(wire_: crate::wire::NamespaceEntry<'de>) -> Self {
515 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
516
517 let path = wire_.table.get(1);
518
519 let directory = wire_.table.get(2);
520
521 Self {
522 path: path.map(|envelope| {
523 ::fidl_next::FromWire::from_wire(unsafe {
524 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
525 })
526 }),
527
528 directory: directory.map(|envelope| {
529 ::fidl_next::FromWire::from_wire(unsafe {
530 envelope.read_unchecked::<::fidl_next::ClientEnd<
531 ::fidl_next_fuchsia_io::Directory,
532 ::fidl_next::wire::fuchsia::Channel,
533 >>()
534 })
535 }),
536 }
537 }
538 }
539
540 #[derive(Debug, Default, PartialEq)]
541 pub struct StartChildArgs {
542 pub numbered_handles: ::core::option::Option<
543 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
544 >,
545
546 pub namespace_entries:
547 ::core::option::Option<::std::vec::Vec<crate::natural::NamespaceEntry>>,
548
549 pub dictionary:
550 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
551
552 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
553 }
554
555 impl StartChildArgs {
556 fn __max_ordinal(&self) -> usize {
557 if self.additional_inputs.is_some() {
558 return 4;
559 }
560
561 if self.dictionary.is_some() {
562 return 3;
563 }
564
565 if self.namespace_entries.is_some() {
566 return 2;
567 }
568
569 if self.numbered_handles.is_some() {
570 return 1;
571 }
572
573 0
574 }
575 }
576
577 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E> for StartChildArgs
578 where
579 ___E: ::fidl_next::Encoder + ?Sized,
580 ___E: ::fidl_next::fuchsia::HandleEncoder,
581 {
582 #[inline]
583 fn encode(
584 mut self,
585 encoder: &mut ___E,
586 out: &mut ::core::mem::MaybeUninit<crate::wire::StartChildArgs<'static>>,
587 _: (),
588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
589 ::fidl_next::munge!(let crate::wire::StartChildArgs { table } = out);
590
591 let max_ord = self.__max_ordinal();
592
593 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
594 ::fidl_next::Wire::zero_padding(&mut out);
595
596 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
597 ::fidl_next::wire::Envelope,
598 >(encoder, max_ord);
599
600 for i in 1..=max_ord {
601 match i {
602 4 => {
603 if let Some(value) = self.additional_inputs.take() {
604 ::fidl_next::wire::Envelope::encode_value::<
605 ::fidl_next::wire::fuchsia::EventPair,
606 ___E,
607 >(
608 value, preallocated.encoder, &mut out, ()
609 )?;
610 } else {
611 ::fidl_next::wire::Envelope::encode_zero(&mut out)
612 }
613 }
614
615 3 => {
616 if let Some(value) = self.dictionary.take() {
617 ::fidl_next::wire::Envelope::encode_value::<
618 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
619 ___E,
620 >(
621 value, preallocated.encoder, &mut out, ()
622 )?;
623 } else {
624 ::fidl_next::wire::Envelope::encode_zero(&mut out)
625 }
626 }
627
628 2 => {
629 if let Some(value) = self.namespace_entries.take() {
630 ::fidl_next::wire::Envelope::encode_value::<
631 ::fidl_next::wire::Vector<
632 'static,
633 crate::wire::NamespaceEntry<'static>,
634 >,
635 ___E,
636 >(
637 value, preallocated.encoder, &mut out, (32, ())
638 )?;
639 } else {
640 ::fidl_next::wire::Envelope::encode_zero(&mut out)
641 }
642 }
643
644 1 => {
645 if let Some(value) = self.numbered_handles.take() {
646 ::fidl_next::wire::Envelope::encode_value::<
647 ::fidl_next::wire::Vector<
648 'static,
649 ::fidl_next_fuchsia_process::wire::HandleInfo,
650 >,
651 ___E,
652 >(
653 value, preallocated.encoder, &mut out, (128, ())
654 )?;
655 } else {
656 ::fidl_next::wire::Envelope::encode_zero(&mut out)
657 }
658 }
659
660 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
661 }
662 unsafe {
663 preallocated.write_next(out.assume_init_ref());
664 }
665 }
666
667 ::fidl_next::wire::Table::encode_len(table, max_ord);
668
669 Ok(())
670 }
671 }
672
673 impl<'de> ::fidl_next::FromWire<crate::wire::StartChildArgs<'de>> for StartChildArgs {
674 #[inline]
675 fn from_wire(wire_: crate::wire::StartChildArgs<'de>) -> Self {
676 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
677
678 let numbered_handles = wire_.table.get(1);
679
680 let namespace_entries = wire_.table.get(2);
681
682 let dictionary = wire_.table.get(3);
683
684 let additional_inputs = wire_.table.get(4);
685
686 Self {
687
688
689 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
690 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
691 )),
692
693
694 namespace_entries: namespace_entries.map(|envelope| ::fidl_next::FromWire::from_wire(
695 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>() }
696 )),
697
698
699 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
700 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
701 )),
702
703
704 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
705 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
706 )),
707
708 }
709 }
710 }
711
712 #[derive(Debug, PartialEq)]
713 pub struct ControllerStartRequest {
714 pub args: crate::natural::StartChildArgs,
715
716 pub execution_controller:
717 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::fuchsia::zx::Channel>,
718 }
719
720 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
721 for ControllerStartRequest
722 where
723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
724 ___E: ::fidl_next::Encoder,
725 ___E: ::fidl_next::fuchsia::HandleEncoder,
726 {
727 #[inline]
728 fn encode(
729 self,
730 encoder_: &mut ___E,
731 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
732 _: (),
733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
734 ::fidl_next::munge! {
735 let crate::wire::ControllerStartRequest {
736 args,
737 execution_controller,
738
739 } = out_;
740 }
741
742 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
743
744 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
745
746 ::fidl_next::Encode::encode(
747 self.execution_controller,
748 encoder_,
749 execution_controller,
750 (),
751 )?;
752
753 let mut _field =
754 unsafe { ::fidl_next::Slot::new_unchecked(execution_controller.as_mut_ptr()) };
755
756 Ok(())
757 }
758 }
759
760 unsafe impl<___E>
761 ::fidl_next::EncodeOption<
762 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
763 ___E,
764 > for ControllerStartRequest
765 where
766 ___E: ::fidl_next::Encoder + ?Sized,
767 ControllerStartRequest:
768 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>,
769 {
770 #[inline]
771 fn encode_option(
772 this: ::core::option::Option<Self>,
773 encoder: &mut ___E,
774 out: &mut ::core::mem::MaybeUninit<
775 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
776 >,
777 _: (),
778 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
779 if let Some(inner) = this {
780 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
781 ::fidl_next::wire::Box::encode_present(out);
782 } else {
783 ::fidl_next::wire::Box::encode_absent(out);
784 }
785
786 Ok(())
787 }
788 }
789
790 impl<'de> ::fidl_next::FromWire<crate::wire::ControllerStartRequest<'de>>
791 for ControllerStartRequest
792 {
793 #[inline]
794 fn from_wire(wire: crate::wire::ControllerStartRequest<'de>) -> Self {
795 Self {
796 args: ::fidl_next::FromWire::from_wire(wire.args),
797
798 execution_controller: ::fidl_next::FromWire::from_wire(wire.execution_controller),
799 }
800 }
801 }
802
803 #[derive(Debug, PartialEq)]
804 #[repr(C)]
805 pub struct ControllerOpenExposedDirRequest {
806 pub exposed_dir: ::fidl_next::ServerEnd<
807 ::fidl_next_fuchsia_io::Directory,
808 ::fidl_next::fuchsia::zx::Channel,
809 >,
810 }
811
812 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
813 for ControllerOpenExposedDirRequest
814 where
815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
816 ___E: ::fidl_next::fuchsia::HandleEncoder,
817 {
818 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
819 Self,
820 crate::wire::ControllerOpenExposedDirRequest,
821 > = unsafe {
822 ::fidl_next::CopyOptimization::enable_if(
823 true && <::fidl_next::ServerEnd<
824 ::fidl_next_fuchsia_io::Directory,
825 ::fidl_next::fuchsia::zx::Channel,
826 > as ::fidl_next::Encode<
827 ::fidl_next::ServerEnd<
828 ::fidl_next_fuchsia_io::Directory,
829 ::fidl_next::wire::fuchsia::Channel,
830 >,
831 ___E,
832 >>::COPY_OPTIMIZATION
833 .is_enabled(),
834 )
835 };
836
837 #[inline]
838 fn encode(
839 self,
840 encoder_: &mut ___E,
841 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
842 _: (),
843 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
844 ::fidl_next::munge! {
845 let crate::wire::ControllerOpenExposedDirRequest {
846 exposed_dir,
847
848 } = out_;
849 }
850
851 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
852
853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
854
855 Ok(())
856 }
857 }
858
859 unsafe impl<___E>
860 ::fidl_next::EncodeOption<
861 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
862 ___E,
863 > for ControllerOpenExposedDirRequest
864 where
865 ___E: ::fidl_next::Encoder + ?Sized,
866 ControllerOpenExposedDirRequest:
867 ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>,
868 {
869 #[inline]
870 fn encode_option(
871 this: ::core::option::Option<Self>,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<
874 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
875 >,
876 _: (),
877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
878 if let Some(inner) = this {
879 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
880 ::fidl_next::wire::Box::encode_present(out);
881 } else {
882 ::fidl_next::wire::Box::encode_absent(out);
883 }
884
885 Ok(())
886 }
887 }
888
889 impl ::fidl_next::FromWire<crate::wire::ControllerOpenExposedDirRequest>
890 for ControllerOpenExposedDirRequest
891 {
892 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
893 crate::wire::ControllerOpenExposedDirRequest,
894 Self,
895 > = unsafe {
896 ::fidl_next::CopyOptimization::enable_if(
897 true && <::fidl_next::ServerEnd<
898 ::fidl_next_fuchsia_io::Directory,
899 ::fidl_next::fuchsia::zx::Channel,
900 > as ::fidl_next::FromWire<
901 ::fidl_next::ServerEnd<
902 ::fidl_next_fuchsia_io::Directory,
903 ::fidl_next::wire::fuchsia::Channel,
904 >,
905 >>::COPY_OPTIMIZATION
906 .is_enabled(),
907 )
908 };
909
910 #[inline]
911 fn from_wire(wire: crate::wire::ControllerOpenExposedDirRequest) -> Self {
912 Self { exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir) }
913 }
914 }
915
916 #[derive(Debug, Default, PartialEq)]
917 pub struct CreateChildArgs {
918 pub numbered_handles: ::core::option::Option<
919 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
920 >,
921
922 pub dynamic_offers: ::core::option::Option<
923 ::std::vec::Vec<::fidl_next_fuchsia_component_decl::natural::Offer>,
924 >,
925
926 pub controller: ::core::option::Option<
927 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
928 >,
929
930 pub dictionary:
931 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
932
933 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
934 }
935
936 impl CreateChildArgs {
937 fn __max_ordinal(&self) -> usize {
938 if self.additional_inputs.is_some() {
939 return 5;
940 }
941
942 if self.dictionary.is_some() {
943 return 4;
944 }
945
946 if self.controller.is_some() {
947 return 3;
948 }
949
950 if self.dynamic_offers.is_some() {
951 return 2;
952 }
953
954 if self.numbered_handles.is_some() {
955 return 1;
956 }
957
958 0
959 }
960 }
961
962 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>
963 for CreateChildArgs
964 where
965 ___E: ::fidl_next::Encoder + ?Sized,
966 ___E: ::fidl_next::fuchsia::HandleEncoder,
967 {
968 #[inline]
969 fn encode(
970 mut self,
971 encoder: &mut ___E,
972 out: &mut ::core::mem::MaybeUninit<crate::wire::CreateChildArgs<'static>>,
973 _: (),
974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
975 ::fidl_next::munge!(let crate::wire::CreateChildArgs { table } = out);
976
977 let max_ord = self.__max_ordinal();
978
979 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
980 ::fidl_next::Wire::zero_padding(&mut out);
981
982 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
983 ::fidl_next::wire::Envelope,
984 >(encoder, max_ord);
985
986 for i in 1..=max_ord {
987 match i {
988 5 => {
989 if let Some(value) = self.additional_inputs.take() {
990 ::fidl_next::wire::Envelope::encode_value::<
991 ::fidl_next::wire::fuchsia::EventPair,
992 ___E,
993 >(
994 value, preallocated.encoder, &mut out, ()
995 )?;
996 } else {
997 ::fidl_next::wire::Envelope::encode_zero(&mut out)
998 }
999 }
1000
1001 4 => {
1002 if let Some(value) = self.dictionary.take() {
1003 ::fidl_next::wire::Envelope::encode_value::<
1004 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
1005 ___E,
1006 >(
1007 value, preallocated.encoder, &mut out, ()
1008 )?;
1009 } else {
1010 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1011 }
1012 }
1013
1014 3 => {
1015 if let Some(value) = self.controller.take() {
1016 ::fidl_next::wire::Envelope::encode_value::<
1017 ::fidl_next::ServerEnd<
1018 crate::Controller,
1019 ::fidl_next::wire::fuchsia::Channel,
1020 >,
1021 ___E,
1022 >(
1023 value, preallocated.encoder, &mut out, ()
1024 )?;
1025 } else {
1026 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1027 }
1028 }
1029
1030 2 => {
1031 if let Some(value) = self.dynamic_offers.take() {
1032 ::fidl_next::wire::Envelope::encode_value::<
1033 ::fidl_next::wire::Vector<
1034 'static,
1035 ::fidl_next_fuchsia_component_decl::wire::Offer<'static>,
1036 >,
1037 ___E,
1038 >(
1039 value, preallocated.encoder, &mut out, (128, ())
1040 )?;
1041 } else {
1042 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1043 }
1044 }
1045
1046 1 => {
1047 if let Some(value) = self.numbered_handles.take() {
1048 ::fidl_next::wire::Envelope::encode_value::<
1049 ::fidl_next::wire::Vector<
1050 'static,
1051 ::fidl_next_fuchsia_process::wire::HandleInfo,
1052 >,
1053 ___E,
1054 >(
1055 value, preallocated.encoder, &mut out, (128, ())
1056 )?;
1057 } else {
1058 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1059 }
1060 }
1061
1062 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1063 }
1064 unsafe {
1065 preallocated.write_next(out.assume_init_ref());
1066 }
1067 }
1068
1069 ::fidl_next::wire::Table::encode_len(table, max_ord);
1070
1071 Ok(())
1072 }
1073 }
1074
1075 impl<'de> ::fidl_next::FromWire<crate::wire::CreateChildArgs<'de>> for CreateChildArgs {
1076 #[inline]
1077 fn from_wire(wire_: crate::wire::CreateChildArgs<'de>) -> Self {
1078 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1079
1080 let numbered_handles = wire_.table.get(1);
1081
1082 let dynamic_offers = wire_.table.get(2);
1083
1084 let controller = wire_.table.get(3);
1085
1086 let dictionary = wire_.table.get(4);
1087
1088 let additional_inputs = wire_.table.get(5);
1089
1090 Self {
1091
1092
1093 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
1094 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
1095 )),
1096
1097
1098 dynamic_offers: dynamic_offers.map(|envelope| ::fidl_next::FromWire::from_wire(
1099 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>>() }
1100 )),
1101
1102
1103 controller: controller.map(|envelope| ::fidl_next::FromWire::from_wire(
1104 unsafe { envelope.read_unchecked::<::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>>() }
1105 )),
1106
1107
1108 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
1109 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
1110 )),
1111
1112
1113 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
1114 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
1115 )),
1116
1117 }
1118 }
1119 }
1120
1121 #[doc = " Payload for DebugStarted events.\n"]
1122 #[derive(Debug, Default, PartialEq)]
1123 pub struct DebugStartedPayload {
1124 pub runtime_dir: ::core::option::Option<
1125 ::fidl_next::ClientEnd<
1126 ::fidl_next_fuchsia_io::Directory,
1127 ::fidl_next::fuchsia::zx::Channel,
1128 >,
1129 >,
1130
1131 pub break_on_start: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
1132 }
1133
1134 impl DebugStartedPayload {
1135 fn __max_ordinal(&self) -> usize {
1136 if self.break_on_start.is_some() {
1137 return 2;
1138 }
1139
1140 if self.runtime_dir.is_some() {
1141 return 1;
1142 }
1143
1144 0
1145 }
1146 }
1147
1148 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugStartedPayload<'static>, ___E>
1149 for DebugStartedPayload
1150 where
1151 ___E: ::fidl_next::Encoder + ?Sized,
1152 ___E: ::fidl_next::fuchsia::HandleEncoder,
1153 {
1154 #[inline]
1155 fn encode(
1156 mut self,
1157 encoder: &mut ___E,
1158 out: &mut ::core::mem::MaybeUninit<crate::wire::DebugStartedPayload<'static>>,
1159 _: (),
1160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1161 ::fidl_next::munge!(let crate::wire::DebugStartedPayload { table } = out);
1162
1163 let max_ord = self.__max_ordinal();
1164
1165 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1166 ::fidl_next::Wire::zero_padding(&mut out);
1167
1168 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1169 ::fidl_next::wire::Envelope,
1170 >(encoder, max_ord);
1171
1172 for i in 1..=max_ord {
1173 match i {
1174 2 => {
1175 if let Some(value) = self.break_on_start.take() {
1176 ::fidl_next::wire::Envelope::encode_value::<
1177 ::fidl_next::wire::fuchsia::EventPair,
1178 ___E,
1179 >(
1180 value, preallocated.encoder, &mut out, ()
1181 )?;
1182 } else {
1183 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1184 }
1185 }
1186
1187 1 => {
1188 if let Some(value) = self.runtime_dir.take() {
1189 ::fidl_next::wire::Envelope::encode_value::<
1190 ::fidl_next::ClientEnd<
1191 ::fidl_next_fuchsia_io::Directory,
1192 ::fidl_next::wire::fuchsia::Channel,
1193 >,
1194 ___E,
1195 >(
1196 value, preallocated.encoder, &mut out, ()
1197 )?;
1198 } else {
1199 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1200 }
1201 }
1202
1203 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1204 }
1205 unsafe {
1206 preallocated.write_next(out.assume_init_ref());
1207 }
1208 }
1209
1210 ::fidl_next::wire::Table::encode_len(table, max_ord);
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl<'de> ::fidl_next::FromWire<crate::wire::DebugStartedPayload<'de>> for DebugStartedPayload {
1217 #[inline]
1218 fn from_wire(wire_: crate::wire::DebugStartedPayload<'de>) -> Self {
1219 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1220
1221 let runtime_dir = wire_.table.get(1);
1222
1223 let break_on_start = wire_.table.get(2);
1224
1225 Self {
1226 runtime_dir: runtime_dir.map(|envelope| {
1227 ::fidl_next::FromWire::from_wire(unsafe {
1228 envelope.read_unchecked::<::fidl_next::ClientEnd<
1229 ::fidl_next_fuchsia_io::Directory,
1230 ::fidl_next::wire::fuchsia::Channel,
1231 >>()
1232 })
1233 }),
1234
1235 break_on_start: break_on_start.map(|envelope| {
1236 ::fidl_next::FromWire::from_wire(unsafe {
1237 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
1238 })
1239 }),
1240 }
1241 }
1242 }
1243
1244 #[doc = " Encapsulates additional data/protocols for some event types.\n"]
1245 #[derive(Debug, PartialEq)]
1246 pub enum EventPayload {
1247 CapabilityRequested(crate::natural::CapabilityRequestedPayload),
1248
1249 Purged(crate::natural::PurgedPayload),
1250
1251 Discovered(crate::natural::DiscoveredPayload),
1252
1253 Destroyed(crate::natural::DestroyedPayload),
1254
1255 Resolved(crate::natural::ResolvedPayload),
1256
1257 Started(crate::natural::StartedPayload),
1258
1259 Stopped(crate::natural::StoppedPayload),
1260
1261 DebugStarted(crate::natural::DebugStartedPayload),
1262
1263 Unresolved(crate::natural::UnresolvedPayload),
1264
1265 UnknownOrdinal_(u64),
1266 }
1267
1268 impl EventPayload {
1269 pub fn is_unknown(&self) -> bool {
1270 #[allow(unreachable_patterns)]
1271 match self {
1272 Self::UnknownOrdinal_(_) => true,
1273 _ => false,
1274 }
1275 }
1276 }
1277
1278 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E> for EventPayload
1279 where
1280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1281 ___E: ::fidl_next::Encoder,
1282 ___E: ::fidl_next::fuchsia::HandleEncoder,
1283 {
1284 #[inline]
1285 fn encode(
1286 self,
1287 encoder: &mut ___E,
1288 out: &mut ::core::mem::MaybeUninit<crate::wire::EventPayload<'static>>,
1289 _: (),
1290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1291 ::fidl_next::munge!(let crate::wire::EventPayload { raw, _phantom: _ } = out);
1292
1293 match self {
1294 Self::CapabilityRequested(value) => ::fidl_next::wire::Union::encode_as::<
1295 ___E,
1296 crate::wire::CapabilityRequestedPayload<'static>,
1297 >(value, 1, encoder, raw, ())?,
1298
1299 Self::Purged(value) => ::fidl_next::wire::Union::encode_as::<
1300 ___E,
1301 crate::wire::PurgedPayload<'static>,
1302 >(value, 2, encoder, raw, ())?,
1303
1304 Self::Discovered(value) => ::fidl_next::wire::Union::encode_as::<
1305 ___E,
1306 crate::wire::DiscoveredPayload<'static>,
1307 >(value, 4, encoder, raw, ())?,
1308
1309 Self::Destroyed(value) => ::fidl_next::wire::Union::encode_as::<
1310 ___E,
1311 crate::wire::DestroyedPayload<'static>,
1312 >(value, 5, encoder, raw, ())?,
1313
1314 Self::Resolved(value) => ::fidl_next::wire::Union::encode_as::<
1315 ___E,
1316 crate::wire::ResolvedPayload<'static>,
1317 >(value, 6, encoder, raw, ())?,
1318
1319 Self::Started(value) => ::fidl_next::wire::Union::encode_as::<
1320 ___E,
1321 crate::wire::StartedPayload<'static>,
1322 >(value, 7, encoder, raw, ())?,
1323
1324 Self::Stopped(value) => ::fidl_next::wire::Union::encode_as::<
1325 ___E,
1326 crate::wire::StoppedPayload<'static>,
1327 >(value, 8, encoder, raw, ())?,
1328
1329 Self::DebugStarted(value) => ::fidl_next::wire::Union::encode_as::<
1330 ___E,
1331 crate::wire::DebugStartedPayload<'static>,
1332 >(value, 9, encoder, raw, ())?,
1333
1334 Self::Unresolved(value) => ::fidl_next::wire::Union::encode_as::<
1335 ___E,
1336 crate::wire::UnresolvedPayload<'static>,
1337 >(value, 10, encoder, raw, ())?,
1338
1339 Self::UnknownOrdinal_(ordinal) => {
1340 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1341 }
1342 }
1343
1344 Ok(())
1345 }
1346 }
1347
1348 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::EventPayload<'static>, ___E>
1349 for EventPayload
1350 where
1351 ___E: ?Sized,
1352 EventPayload: ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E>,
1353 {
1354 #[inline]
1355 fn encode_option(
1356 this: ::core::option::Option<Self>,
1357 encoder: &mut ___E,
1358 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::EventPayload<'static>>,
1359 _: (),
1360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1361 ::fidl_next::munge!(let crate::wire_optional::EventPayload { raw, _phantom: _ } = &mut *out);
1362
1363 if let Some(inner) = this {
1364 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1365 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1366 } else {
1367 ::fidl_next::wire::Union::encode_absent(raw);
1368 }
1369
1370 Ok(())
1371 }
1372 }
1373
1374 impl<'de> ::fidl_next::FromWire<crate::wire::EventPayload<'de>> for EventPayload {
1375 #[inline]
1376 fn from_wire(wire: crate::wire::EventPayload<'de>) -> Self {
1377 let wire = ::core::mem::ManuallyDrop::new(wire);
1378 match wire.raw.ordinal() {
1379 1 => Self::CapabilityRequested(::fidl_next::FromWire::from_wire(unsafe {
1380 wire.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
1381 })),
1382
1383 2 => Self::Purged(::fidl_next::FromWire::from_wire(unsafe {
1384 wire.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
1385 })),
1386
1387 4 => Self::Discovered(::fidl_next::FromWire::from_wire(unsafe {
1388 wire.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
1389 })),
1390
1391 5 => Self::Destroyed(::fidl_next::FromWire::from_wire(unsafe {
1392 wire.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
1393 })),
1394
1395 6 => Self::Resolved(::fidl_next::FromWire::from_wire(unsafe {
1396 wire.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
1397 })),
1398
1399 7 => Self::Started(::fidl_next::FromWire::from_wire(unsafe {
1400 wire.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
1401 })),
1402
1403 8 => Self::Stopped(::fidl_next::FromWire::from_wire(unsafe {
1404 wire.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
1405 })),
1406
1407 9 => Self::DebugStarted(::fidl_next::FromWire::from_wire(unsafe {
1408 wire.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
1409 })),
1410
1411 10 => Self::Unresolved(::fidl_next::FromWire::from_wire(unsafe {
1412 wire.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
1413 })),
1414
1415 ord => return Self::UnknownOrdinal_(ord as u64),
1416 }
1417 }
1418 }
1419
1420 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>> for EventPayload {
1421 #[inline]
1422 fn from_wire_option(
1423 wire: crate::wire_optional::EventPayload<'de>,
1424 ) -> ::core::option::Option<Self> {
1425 if let Some(inner) = wire.into_option() {
1426 Some(::fidl_next::FromWire::from_wire(inner))
1427 } else {
1428 None
1429 }
1430 }
1431 }
1432
1433 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1434 for Box<EventPayload>
1435 {
1436 #[inline]
1437 fn from_wire_option(
1438 wire: crate::wire_optional::EventPayload<'de>,
1439 ) -> ::core::option::Option<Self> {
1440 <
1441 EventPayload as ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1442 >::from_wire_option(wire).map(Box::new)
1443 }
1444 }
1445
1446 #[doc = " Contains all information about a single event\n"]
1447 #[derive(Debug, Default, PartialEq)]
1448 pub struct Event {
1449 pub header: ::core::option::Option<crate::natural::EventHeader>,
1450
1451 pub payload: ::core::option::Option<crate::natural::EventPayload>,
1452 }
1453
1454 impl Event {
1455 fn __max_ordinal(&self) -> usize {
1456 if self.payload.is_some() {
1457 return 2;
1458 }
1459
1460 if self.header.is_some() {
1461 return 1;
1462 }
1463
1464 0
1465 }
1466 }
1467
1468 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Event<'static>, ___E> for Event
1469 where
1470 ___E: ::fidl_next::Encoder + ?Sized,
1471 ___E: ::fidl_next::fuchsia::HandleEncoder,
1472 {
1473 #[inline]
1474 fn encode(
1475 mut self,
1476 encoder: &mut ___E,
1477 out: &mut ::core::mem::MaybeUninit<crate::wire::Event<'static>>,
1478 _: (),
1479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1480 ::fidl_next::munge!(let crate::wire::Event { table } = out);
1481
1482 let max_ord = self.__max_ordinal();
1483
1484 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1485 ::fidl_next::Wire::zero_padding(&mut out);
1486
1487 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1488 ::fidl_next::wire::Envelope,
1489 >(encoder, max_ord);
1490
1491 for i in 1..=max_ord {
1492 match i {
1493 2 => {
1494 if let Some(value) = self.payload.take() {
1495 ::fidl_next::wire::Envelope::encode_value::<
1496 crate::wire::EventPayload<'static>,
1497 ___E,
1498 >(
1499 value, preallocated.encoder, &mut out, ()
1500 )?;
1501 } else {
1502 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1503 }
1504 }
1505
1506 1 => {
1507 if let Some(value) = self.header.take() {
1508 ::fidl_next::wire::Envelope::encode_value::<
1509 crate::wire::EventHeader<'static>,
1510 ___E,
1511 >(
1512 value, preallocated.encoder, &mut out, ()
1513 )?;
1514 } else {
1515 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1516 }
1517 }
1518
1519 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1520 }
1521 unsafe {
1522 preallocated.write_next(out.assume_init_ref());
1523 }
1524 }
1525
1526 ::fidl_next::wire::Table::encode_len(table, max_ord);
1527
1528 Ok(())
1529 }
1530 }
1531
1532 impl<'de> ::fidl_next::FromWire<crate::wire::Event<'de>> for Event {
1533 #[inline]
1534 fn from_wire(wire_: crate::wire::Event<'de>) -> Self {
1535 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1536
1537 let header = wire_.table.get(1);
1538
1539 let payload = wire_.table.get(2);
1540
1541 Self {
1542 header: header.map(|envelope| {
1543 ::fidl_next::FromWire::from_wire(unsafe {
1544 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
1545 })
1546 }),
1547
1548 payload: payload.map(|envelope| {
1549 ::fidl_next::FromWire::from_wire(unsafe {
1550 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
1551 })
1552 }),
1553 }
1554 }
1555 }
1556
1557 #[derive(Debug, PartialEq)]
1558 pub struct EventStreamGetNextResponse {
1559 pub events: ::std::vec::Vec<crate::natural::Event>,
1560 }
1561
1562 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
1563 for EventStreamGetNextResponse
1564 where
1565 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1566 ___E: ::fidl_next::Encoder,
1567 ___E: ::fidl_next::fuchsia::HandleEncoder,
1568 {
1569 #[inline]
1570 fn encode(
1571 self,
1572 encoder_: &mut ___E,
1573 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
1574 _: (),
1575 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1576 ::fidl_next::munge! {
1577 let crate::wire::EventStreamGetNextResponse {
1578 events,
1579
1580 } = out_;
1581 }
1582
1583 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
1584
1585 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(events.as_mut_ptr()) };
1586 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1587
1588 Ok(())
1589 }
1590 }
1591
1592 unsafe impl<___E>
1593 ::fidl_next::EncodeOption<
1594 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1595 ___E,
1596 > for EventStreamGetNextResponse
1597 where
1598 ___E: ::fidl_next::Encoder + ?Sized,
1599 EventStreamGetNextResponse:
1600 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>,
1601 {
1602 #[inline]
1603 fn encode_option(
1604 this: ::core::option::Option<Self>,
1605 encoder: &mut ___E,
1606 out: &mut ::core::mem::MaybeUninit<
1607 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1608 >,
1609 _: (),
1610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1611 if let Some(inner) = this {
1612 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1613 ::fidl_next::wire::Box::encode_present(out);
1614 } else {
1615 ::fidl_next::wire::Box::encode_absent(out);
1616 }
1617
1618 Ok(())
1619 }
1620 }
1621
1622 impl<'de> ::fidl_next::FromWire<crate::wire::EventStreamGetNextResponse<'de>>
1623 for EventStreamGetNextResponse
1624 {
1625 #[inline]
1626 fn from_wire(wire: crate::wire::EventStreamGetNextResponse<'de>) -> Self {
1627 Self { events: ::fidl_next::FromWire::from_wire(wire.events) }
1628 }
1629 }
1630
1631 #[derive(Debug, PartialEq)]
1632 #[repr(C)]
1633 pub struct IntrospectorGetMonikerRequest {
1634 pub component_instance: ::fidl_next::fuchsia::zx::Event,
1635 }
1636
1637 unsafe impl<___E> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
1638 for IntrospectorGetMonikerRequest
1639 where
1640 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1641 ___E: ::fidl_next::fuchsia::HandleEncoder,
1642 {
1643 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1644 Self,
1645 crate::wire::IntrospectorGetMonikerRequest,
1646 > = unsafe {
1647 ::fidl_next::CopyOptimization::enable_if(
1648 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
1649 ::fidl_next::wire::fuchsia::Event,
1650 ___E,
1651 >>::COPY_OPTIMIZATION
1652 .is_enabled(),
1653 )
1654 };
1655
1656 #[inline]
1657 fn encode(
1658 self,
1659 encoder_: &mut ___E,
1660 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
1661 _: (),
1662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1663 ::fidl_next::munge! {
1664 let crate::wire::IntrospectorGetMonikerRequest {
1665 component_instance,
1666
1667 } = out_;
1668 }
1669
1670 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
1671
1672 let mut _field =
1673 unsafe { ::fidl_next::Slot::new_unchecked(component_instance.as_mut_ptr()) };
1674
1675 Ok(())
1676 }
1677 }
1678
1679 unsafe impl<___E>
1680 ::fidl_next::EncodeOption<
1681 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1682 ___E,
1683 > for IntrospectorGetMonikerRequest
1684 where
1685 ___E: ::fidl_next::Encoder + ?Sized,
1686 IntrospectorGetMonikerRequest:
1687 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>,
1688 {
1689 #[inline]
1690 fn encode_option(
1691 this: ::core::option::Option<Self>,
1692 encoder: &mut ___E,
1693 out: &mut ::core::mem::MaybeUninit<
1694 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1695 >,
1696 _: (),
1697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1698 if let Some(inner) = this {
1699 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1700 ::fidl_next::wire::Box::encode_present(out);
1701 } else {
1702 ::fidl_next::wire::Box::encode_absent(out);
1703 }
1704
1705 Ok(())
1706 }
1707 }
1708
1709 impl ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerRequest>
1710 for IntrospectorGetMonikerRequest
1711 {
1712 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1713 crate::wire::IntrospectorGetMonikerRequest,
1714 Self,
1715 > = unsafe {
1716 ::fidl_next::CopyOptimization::enable_if(
1717 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
1718 ::fidl_next::wire::fuchsia::Event,
1719 >>::COPY_OPTIMIZATION
1720 .is_enabled(),
1721 )
1722 };
1723
1724 #[inline]
1725 fn from_wire(wire: crate::wire::IntrospectorGetMonikerRequest) -> Self {
1726 Self { component_instance: ::fidl_next::FromWire::from_wire(wire.component_instance) }
1727 }
1728 }
1729
1730 #[derive(Debug, PartialEq)]
1731 pub struct NamespaceInputEntry {
1732 pub path: ::std::string::String,
1733
1734 pub dictionary: ::fidl_next::ClientEnd<
1735 ::fidl_next_fuchsia_component_sandbox::Dictionary,
1736 ::fidl_next::fuchsia::zx::Channel,
1737 >,
1738 }
1739
1740 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
1741 for NamespaceInputEntry
1742 where
1743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1744 ___E: ::fidl_next::Encoder,
1745 ___E: ::fidl_next::fuchsia::HandleEncoder,
1746 {
1747 #[inline]
1748 fn encode(
1749 self,
1750 encoder_: &mut ___E,
1751 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
1752 _: (),
1753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1754 ::fidl_next::munge! {
1755 let crate::wire::NamespaceInputEntry {
1756 path,
1757 dictionary,
1758
1759 } = out_;
1760 }
1761
1762 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1763
1764 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1765 ::fidl_next::Constrained::validate(_field, 4095)?;
1766
1767 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
1768
1769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
1770
1771 Ok(())
1772 }
1773 }
1774
1775 unsafe impl<___E>
1776 ::fidl_next::EncodeOption<
1777 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1778 ___E,
1779 > for NamespaceInputEntry
1780 where
1781 ___E: ::fidl_next::Encoder + ?Sized,
1782 NamespaceInputEntry: ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1790 >,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 if let Some(inner) = this {
1794 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1795 ::fidl_next::wire::Box::encode_present(out);
1796 } else {
1797 ::fidl_next::wire::Box::encode_absent(out);
1798 }
1799
1800 Ok(())
1801 }
1802 }
1803
1804 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry<'de>> for NamespaceInputEntry {
1805 #[inline]
1806 fn from_wire(wire: crate::wire::NamespaceInputEntry<'de>) -> Self {
1807 Self {
1808 path: ::fidl_next::FromWire::from_wire(wire.path),
1809
1810 dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary),
1811 }
1812 }
1813 }
1814
1815 #[derive(Debug, PartialEq)]
1816 pub struct NamespaceCreateRequest {
1817 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry>,
1818 }
1819
1820 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
1821 for NamespaceCreateRequest
1822 where
1823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1824 ___E: ::fidl_next::Encoder,
1825 ___E: ::fidl_next::fuchsia::HandleEncoder,
1826 {
1827 #[inline]
1828 fn encode(
1829 self,
1830 encoder_: &mut ___E,
1831 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
1832 _: (),
1833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1834 ::fidl_next::munge! {
1835 let crate::wire::NamespaceCreateRequest {
1836 entries,
1837
1838 } = out_;
1839 }
1840
1841 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1842
1843 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
1844 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1845
1846 Ok(())
1847 }
1848 }
1849
1850 unsafe impl<___E>
1851 ::fidl_next::EncodeOption<
1852 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1853 ___E,
1854 > for NamespaceCreateRequest
1855 where
1856 ___E: ::fidl_next::Encoder + ?Sized,
1857 NamespaceCreateRequest:
1858 ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>,
1859 {
1860 #[inline]
1861 fn encode_option(
1862 this: ::core::option::Option<Self>,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<
1865 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1866 >,
1867 _: (),
1868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1869 if let Some(inner) = this {
1870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1871 ::fidl_next::wire::Box::encode_present(out);
1872 } else {
1873 ::fidl_next::wire::Box::encode_absent(out);
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateRequest<'de>>
1881 for NamespaceCreateRequest
1882 {
1883 #[inline]
1884 fn from_wire(wire: crate::wire::NamespaceCreateRequest<'de>) -> Self {
1885 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
1886 }
1887 }
1888
1889 #[derive(Debug, PartialEq)]
1890 pub struct NamespaceInputEntry2 {
1891 pub path: ::std::string::String,
1892
1893 pub capability: ::fidl_next::fuchsia::zx::EventPair,
1894 }
1895
1896 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
1897 for NamespaceInputEntry2
1898 where
1899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1900 ___E: ::fidl_next::Encoder,
1901 ___E: ::fidl_next::fuchsia::HandleEncoder,
1902 {
1903 #[inline]
1904 fn encode(
1905 self,
1906 encoder_: &mut ___E,
1907 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge! {
1911 let crate::wire::NamespaceInputEntry2 {
1912 path,
1913 capability,
1914
1915 } = out_;
1916 }
1917
1918 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1919
1920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1921 ::fidl_next::Constrained::validate(_field, 4095)?;
1922
1923 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1924
1925 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1926
1927 Ok(())
1928 }
1929 }
1930
1931 unsafe impl<___E>
1932 ::fidl_next::EncodeOption<
1933 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1934 ___E,
1935 > for NamespaceInputEntry2
1936 where
1937 ___E: ::fidl_next::Encoder + ?Sized,
1938 NamespaceInputEntry2: ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>,
1939 {
1940 #[inline]
1941 fn encode_option(
1942 this: ::core::option::Option<Self>,
1943 encoder: &mut ___E,
1944 out: &mut ::core::mem::MaybeUninit<
1945 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1946 >,
1947 _: (),
1948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1949 if let Some(inner) = this {
1950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1951 ::fidl_next::wire::Box::encode_present(out);
1952 } else {
1953 ::fidl_next::wire::Box::encode_absent(out);
1954 }
1955
1956 Ok(())
1957 }
1958 }
1959
1960 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry2<'de>> for NamespaceInputEntry2 {
1961 #[inline]
1962 fn from_wire(wire: crate::wire::NamespaceInputEntry2<'de>) -> Self {
1963 Self {
1964 path: ::fidl_next::FromWire::from_wire(wire.path),
1965
1966 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1967 }
1968 }
1969 }
1970
1971 #[derive(Debug, PartialEq)]
1972 pub struct NamespaceCreate2Request {
1973 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry2>,
1974 }
1975
1976 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
1977 for NamespaceCreate2Request
1978 where
1979 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1980 ___E: ::fidl_next::Encoder,
1981 ___E: ::fidl_next::fuchsia::HandleEncoder,
1982 {
1983 #[inline]
1984 fn encode(
1985 self,
1986 encoder_: &mut ___E,
1987 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
1988 _: (),
1989 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1990 ::fidl_next::munge! {
1991 let crate::wire::NamespaceCreate2Request {
1992 entries,
1993
1994 } = out_;
1995 }
1996
1997 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1998
1999 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2000 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2001
2002 Ok(())
2003 }
2004 }
2005
2006 unsafe impl<___E>
2007 ::fidl_next::EncodeOption<
2008 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2009 ___E,
2010 > for NamespaceCreate2Request
2011 where
2012 ___E: ::fidl_next::Encoder + ?Sized,
2013 NamespaceCreate2Request:
2014 ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>,
2015 {
2016 #[inline]
2017 fn encode_option(
2018 this: ::core::option::Option<Self>,
2019 encoder: &mut ___E,
2020 out: &mut ::core::mem::MaybeUninit<
2021 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2022 >,
2023 _: (),
2024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2025 if let Some(inner) = this {
2026 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2027 ::fidl_next::wire::Box::encode_present(out);
2028 } else {
2029 ::fidl_next::wire::Box::encode_absent(out);
2030 }
2031
2032 Ok(())
2033 }
2034 }
2035
2036 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Request<'de>>
2037 for NamespaceCreate2Request
2038 {
2039 #[inline]
2040 fn from_wire(wire: crate::wire::NamespaceCreate2Request<'de>) -> Self {
2041 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2042 }
2043 }
2044
2045 #[derive(Debug, PartialEq)]
2046 pub struct NamespaceCreateResponse {
2047 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2048 }
2049
2050 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
2051 for NamespaceCreateResponse
2052 where
2053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2054 ___E: ::fidl_next::Encoder,
2055 ___E: ::fidl_next::fuchsia::HandleEncoder,
2056 {
2057 #[inline]
2058 fn encode(
2059 self,
2060 encoder_: &mut ___E,
2061 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2064 ::fidl_next::munge! {
2065 let crate::wire::NamespaceCreateResponse {
2066 entries,
2067
2068 } = out_;
2069 }
2070
2071 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2072
2073 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2074 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<___E>
2081 ::fidl_next::EncodeOption<
2082 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2083 ___E,
2084 > for NamespaceCreateResponse
2085 where
2086 ___E: ::fidl_next::Encoder + ?Sized,
2087 NamespaceCreateResponse:
2088 ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>,
2089 {
2090 #[inline]
2091 fn encode_option(
2092 this: ::core::option::Option<Self>,
2093 encoder: &mut ___E,
2094 out: &mut ::core::mem::MaybeUninit<
2095 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2096 >,
2097 _: (),
2098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2099 if let Some(inner) = this {
2100 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2101 ::fidl_next::wire::Box::encode_present(out);
2102 } else {
2103 ::fidl_next::wire::Box::encode_absent(out);
2104 }
2105
2106 Ok(())
2107 }
2108 }
2109
2110 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateResponse<'de>>
2111 for NamespaceCreateResponse
2112 {
2113 #[inline]
2114 fn from_wire(wire: crate::wire::NamespaceCreateResponse<'de>) -> Self {
2115 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2116 }
2117 }
2118
2119 #[derive(Debug, PartialEq)]
2120 pub struct NamespaceCreate2Response {
2121 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2122 }
2123
2124 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
2125 for NamespaceCreate2Response
2126 where
2127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2128 ___E: ::fidl_next::Encoder,
2129 ___E: ::fidl_next::fuchsia::HandleEncoder,
2130 {
2131 #[inline]
2132 fn encode(
2133 self,
2134 encoder_: &mut ___E,
2135 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
2136 _: (),
2137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2138 ::fidl_next::munge! {
2139 let crate::wire::NamespaceCreate2Response {
2140 entries,
2141
2142 } = out_;
2143 }
2144
2145 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2146
2147 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2148 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2149
2150 Ok(())
2151 }
2152 }
2153
2154 unsafe impl<___E>
2155 ::fidl_next::EncodeOption<
2156 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2157 ___E,
2158 > for NamespaceCreate2Response
2159 where
2160 ___E: ::fidl_next::Encoder + ?Sized,
2161 NamespaceCreate2Response:
2162 ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>,
2163 {
2164 #[inline]
2165 fn encode_option(
2166 this: ::core::option::Option<Self>,
2167 encoder: &mut ___E,
2168 out: &mut ::core::mem::MaybeUninit<
2169 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2170 >,
2171 _: (),
2172 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2173 if let Some(inner) = this {
2174 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2175 ::fidl_next::wire::Box::encode_present(out);
2176 } else {
2177 ::fidl_next::wire::Box::encode_absent(out);
2178 }
2179
2180 Ok(())
2181 }
2182 }
2183
2184 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Response<'de>>
2185 for NamespaceCreate2Response
2186 {
2187 #[inline]
2188 fn from_wire(wire: crate::wire::NamespaceCreate2Response<'de>) -> Self {
2189 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2190 }
2191 }
2192
2193 #[derive(Debug, PartialEq)]
2194 pub struct RealmListChildrenRequest {
2195 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2196
2197 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::fuchsia::zx::Channel>,
2198 }
2199
2200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
2201 for RealmListChildrenRequest
2202 where
2203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2204 ___E: ::fidl_next::Encoder,
2205 ___E: ::fidl_next::fuchsia::HandleEncoder,
2206 {
2207 #[inline]
2208 fn encode(
2209 self,
2210 encoder_: &mut ___E,
2211 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
2212 _: (),
2213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2214 ::fidl_next::munge! {
2215 let crate::wire::RealmListChildrenRequest {
2216 collection,
2217 iter,
2218
2219 } = out_;
2220 }
2221
2222 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2223
2224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2225
2226 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
2227
2228 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iter.as_mut_ptr()) };
2229
2230 Ok(())
2231 }
2232 }
2233
2234 unsafe impl<___E>
2235 ::fidl_next::EncodeOption<
2236 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2237 ___E,
2238 > for RealmListChildrenRequest
2239 where
2240 ___E: ::fidl_next::Encoder + ?Sized,
2241 RealmListChildrenRequest:
2242 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>,
2243 {
2244 #[inline]
2245 fn encode_option(
2246 this: ::core::option::Option<Self>,
2247 encoder: &mut ___E,
2248 out: &mut ::core::mem::MaybeUninit<
2249 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2250 >,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 if let Some(inner) = this {
2254 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2255 ::fidl_next::wire::Box::encode_present(out);
2256 } else {
2257 ::fidl_next::wire::Box::encode_absent(out);
2258 }
2259
2260 Ok(())
2261 }
2262 }
2263
2264 impl<'de> ::fidl_next::FromWire<crate::wire::RealmListChildrenRequest<'de>>
2265 for RealmListChildrenRequest
2266 {
2267 #[inline]
2268 fn from_wire(wire: crate::wire::RealmListChildrenRequest<'de>) -> Self {
2269 Self {
2270 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2271
2272 iter: ::fidl_next::FromWire::from_wire(wire.iter),
2273 }
2274 }
2275 }
2276
2277 #[derive(Debug, Clone, PartialEq)]
2278 pub struct RealmGetChildOutputDictionaryDeprecatedRequest {
2279 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2280 }
2281
2282 unsafe impl<___E>
2283 ::fidl_next::Encode<
2284 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2285 ___E,
2286 > for RealmGetChildOutputDictionaryDeprecatedRequest
2287 where
2288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2289 ___E: ::fidl_next::Encoder,
2290 ___E: ::fidl_next::fuchsia::HandleEncoder,
2291 {
2292 #[inline]
2293 fn encode(
2294 self,
2295 encoder_: &mut ___E,
2296 out_: &mut ::core::mem::MaybeUninit<
2297 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2298 >,
2299 _: (),
2300 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2301 ::fidl_next::munge! {
2302 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
2303 child,
2304
2305 } = out_;
2306 }
2307
2308 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2309
2310 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2311
2312 Ok(())
2313 }
2314 }
2315
2316 unsafe impl<___E>
2317 ::fidl_next::EncodeOption<
2318 ::fidl_next::wire::Box<
2319 'static,
2320 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2321 >,
2322 ___E,
2323 > for RealmGetChildOutputDictionaryDeprecatedRequest
2324 where
2325 ___E: ::fidl_next::Encoder + ?Sized,
2326 RealmGetChildOutputDictionaryDeprecatedRequest: ::fidl_next::Encode<
2327 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2328 ___E,
2329 >,
2330 {
2331 #[inline]
2332 fn encode_option(
2333 this: ::core::option::Option<Self>,
2334 encoder: &mut ___E,
2335 out: &mut ::core::mem::MaybeUninit<
2336 ::fidl_next::wire::Box<
2337 'static,
2338 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2339 >,
2340 >,
2341 _: (),
2342 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2343 if let Some(inner) = this {
2344 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2345 ::fidl_next::wire::Box::encode_present(out);
2346 } else {
2347 ::fidl_next::wire::Box::encode_absent(out);
2348 }
2349
2350 Ok(())
2351 }
2352 }
2353
2354 impl<'de>
2355 ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>>
2356 for RealmGetChildOutputDictionaryDeprecatedRequest
2357 {
2358 #[inline]
2359 fn from_wire(
2360 wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>,
2361 ) -> Self {
2362 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2363 }
2364 }
2365
2366 #[derive(Debug, PartialEq)]
2367 #[repr(C)]
2368 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
2369 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
2370 }
2371
2372 unsafe impl<___E>
2373 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
2374 for RealmGetChildOutputDictionaryDeprecatedResponse
2375 where
2376 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2377 ___E: ::fidl_next::fuchsia::HandleEncoder,
2378 {
2379 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2380 Self,
2381 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2382 > = unsafe {
2383 ::fidl_next::CopyOptimization::enable_if(
2384 true
2385
2386 && <
2387 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
2388 >::COPY_OPTIMIZATION.is_enabled()
2389
2390 )
2391 };
2392
2393 #[inline]
2394 fn encode(
2395 self,
2396 encoder_: &mut ___E,
2397 out_: &mut ::core::mem::MaybeUninit<
2398 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2399 >,
2400 _: (),
2401 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2402 ::fidl_next::munge! {
2403 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
2404 dictionary,
2405
2406 } = out_;
2407 }
2408
2409 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2410
2411 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2412
2413 Ok(())
2414 }
2415 }
2416
2417 unsafe impl<___E>
2418 ::fidl_next::EncodeOption<
2419 ::fidl_next::wire::Box<
2420 'static,
2421 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2422 >,
2423 ___E,
2424 > for RealmGetChildOutputDictionaryDeprecatedResponse
2425 where
2426 ___E: ::fidl_next::Encoder + ?Sized,
2427 RealmGetChildOutputDictionaryDeprecatedResponse:
2428 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>,
2429 {
2430 #[inline]
2431 fn encode_option(
2432 this: ::core::option::Option<Self>,
2433 encoder: &mut ___E,
2434 out: &mut ::core::mem::MaybeUninit<
2435 ::fidl_next::wire::Box<
2436 'static,
2437 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2438 >,
2439 >,
2440 _: (),
2441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2442 if let Some(inner) = this {
2443 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2444 ::fidl_next::wire::Box::encode_present(out);
2445 } else {
2446 ::fidl_next::wire::Box::encode_absent(out);
2447 }
2448
2449 Ok(())
2450 }
2451 }
2452
2453 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse>
2454 for RealmGetChildOutputDictionaryDeprecatedResponse
2455 {
2456 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2457 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2458 Self,
2459 > = unsafe {
2460 ::fidl_next::CopyOptimization::enable_if(
2461 true
2462
2463 && <
2464 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
2465 >::COPY_OPTIMIZATION.is_enabled()
2466
2467 )
2468 };
2469
2470 #[inline]
2471 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse) -> Self {
2472 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2473 }
2474 }
2475
2476 #[derive(Debug, Clone, PartialEq)]
2477 pub struct RealmGetChildOutputDictionaryRequest {
2478 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2479 }
2480
2481 unsafe impl<___E>
2482 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
2483 for RealmGetChildOutputDictionaryRequest
2484 where
2485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2486 ___E: ::fidl_next::Encoder,
2487 ___E: ::fidl_next::fuchsia::HandleEncoder,
2488 {
2489 #[inline]
2490 fn encode(
2491 self,
2492 encoder_: &mut ___E,
2493 out_: &mut ::core::mem::MaybeUninit<
2494 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2495 >,
2496 _: (),
2497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2498 ::fidl_next::munge! {
2499 let crate::wire::RealmGetChildOutputDictionaryRequest {
2500 child,
2501
2502 } = out_;
2503 }
2504
2505 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2506
2507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2508
2509 Ok(())
2510 }
2511 }
2512
2513 unsafe impl<___E>
2514 ::fidl_next::EncodeOption<
2515 ::fidl_next::wire::Box<
2516 'static,
2517 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2518 >,
2519 ___E,
2520 > for RealmGetChildOutputDictionaryRequest
2521 where
2522 ___E: ::fidl_next::Encoder + ?Sized,
2523 RealmGetChildOutputDictionaryRequest:
2524 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>,
2525 {
2526 #[inline]
2527 fn encode_option(
2528 this: ::core::option::Option<Self>,
2529 encoder: &mut ___E,
2530 out: &mut ::core::mem::MaybeUninit<
2531 ::fidl_next::wire::Box<
2532 'static,
2533 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2534 >,
2535 >,
2536 _: (),
2537 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2538 if let Some(inner) = this {
2539 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2540 ::fidl_next::wire::Box::encode_present(out);
2541 } else {
2542 ::fidl_next::wire::Box::encode_absent(out);
2543 }
2544
2545 Ok(())
2546 }
2547 }
2548
2549 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryRequest<'de>>
2550 for RealmGetChildOutputDictionaryRequest
2551 {
2552 #[inline]
2553 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryRequest<'de>) -> Self {
2554 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2555 }
2556 }
2557
2558 #[derive(Debug, PartialEq)]
2559 #[repr(C)]
2560 pub struct RealmGetChildOutputDictionaryResponse {
2561 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
2562 }
2563
2564 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
2565 for RealmGetChildOutputDictionaryResponse
2566 where
2567 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2568 ___E: ::fidl_next::fuchsia::HandleEncoder,
2569 {
2570 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2571 Self,
2572 crate::wire::RealmGetChildOutputDictionaryResponse,
2573 > = unsafe {
2574 ::fidl_next::CopyOptimization::enable_if(
2575 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2576 ::fidl_next::wire::fuchsia::EventPair,
2577 ___E,
2578 >>::COPY_OPTIMIZATION
2579 .is_enabled(),
2580 )
2581 };
2582
2583 #[inline]
2584 fn encode(
2585 self,
2586 encoder_: &mut ___E,
2587 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 ::fidl_next::munge! {
2591 let crate::wire::RealmGetChildOutputDictionaryResponse {
2592 dictionary,
2593
2594 } = out_;
2595 }
2596
2597 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2598
2599 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2600
2601 Ok(())
2602 }
2603 }
2604
2605 unsafe impl<___E>
2606 ::fidl_next::EncodeOption<
2607 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2608 ___E,
2609 > for RealmGetChildOutputDictionaryResponse
2610 where
2611 ___E: ::fidl_next::Encoder + ?Sized,
2612 RealmGetChildOutputDictionaryResponse:
2613 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>,
2614 {
2615 #[inline]
2616 fn encode_option(
2617 this: ::core::option::Option<Self>,
2618 encoder: &mut ___E,
2619 out: &mut ::core::mem::MaybeUninit<
2620 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2621 >,
2622 _: (),
2623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2624 if let Some(inner) = this {
2625 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2626 ::fidl_next::wire::Box::encode_present(out);
2627 } else {
2628 ::fidl_next::wire::Box::encode_absent(out);
2629 }
2630
2631 Ok(())
2632 }
2633 }
2634
2635 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryResponse>
2636 for RealmGetChildOutputDictionaryResponse
2637 {
2638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2639 crate::wire::RealmGetChildOutputDictionaryResponse,
2640 Self,
2641 > = unsafe {
2642 ::fidl_next::CopyOptimization::enable_if(
2643 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2644 ::fidl_next::wire::fuchsia::EventPair,
2645 >>::COPY_OPTIMIZATION
2646 .is_enabled(),
2647 )
2648 };
2649
2650 #[inline]
2651 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryResponse) -> Self {
2652 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2653 }
2654 }
2655
2656 #[derive(Debug, PartialEq)]
2657 pub struct RealmOpenControllerRequest {
2658 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2659
2660 pub controller:
2661 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
2662 }
2663
2664 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
2665 for RealmOpenControllerRequest
2666 where
2667 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2668 ___E: ::fidl_next::Encoder,
2669 ___E: ::fidl_next::fuchsia::HandleEncoder,
2670 {
2671 #[inline]
2672 fn encode(
2673 self,
2674 encoder_: &mut ___E,
2675 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
2676 _: (),
2677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2678 ::fidl_next::munge! {
2679 let crate::wire::RealmOpenControllerRequest {
2680 child,
2681 controller,
2682
2683 } = out_;
2684 }
2685
2686 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2687
2688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2689
2690 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
2691
2692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(controller.as_mut_ptr()) };
2693
2694 Ok(())
2695 }
2696 }
2697
2698 unsafe impl<___E>
2699 ::fidl_next::EncodeOption<
2700 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2701 ___E,
2702 > for RealmOpenControllerRequest
2703 where
2704 ___E: ::fidl_next::Encoder + ?Sized,
2705 RealmOpenControllerRequest:
2706 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>,
2707 {
2708 #[inline]
2709 fn encode_option(
2710 this: ::core::option::Option<Self>,
2711 encoder: &mut ___E,
2712 out: &mut ::core::mem::MaybeUninit<
2713 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2714 >,
2715 _: (),
2716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2717 if let Some(inner) = this {
2718 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2719 ::fidl_next::wire::Box::encode_present(out);
2720 } else {
2721 ::fidl_next::wire::Box::encode_absent(out);
2722 }
2723
2724 Ok(())
2725 }
2726 }
2727
2728 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenControllerRequest<'de>>
2729 for RealmOpenControllerRequest
2730 {
2731 #[inline]
2732 fn from_wire(wire: crate::wire::RealmOpenControllerRequest<'de>) -> Self {
2733 Self {
2734 child: ::fidl_next::FromWire::from_wire(wire.child),
2735
2736 controller: ::fidl_next::FromWire::from_wire(wire.controller),
2737 }
2738 }
2739 }
2740
2741 #[derive(Debug, PartialEq)]
2742 pub struct RealmOpenExposedDirRequest {
2743 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2744
2745 pub exposed_dir: ::fidl_next::ServerEnd<
2746 ::fidl_next_fuchsia_io::Directory,
2747 ::fidl_next::fuchsia::zx::Channel,
2748 >,
2749 }
2750
2751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
2752 for RealmOpenExposedDirRequest
2753 where
2754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2755 ___E: ::fidl_next::Encoder,
2756 ___E: ::fidl_next::fuchsia::HandleEncoder,
2757 {
2758 #[inline]
2759 fn encode(
2760 self,
2761 encoder_: &mut ___E,
2762 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
2763 _: (),
2764 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765 ::fidl_next::munge! {
2766 let crate::wire::RealmOpenExposedDirRequest {
2767 child,
2768 exposed_dir,
2769
2770 } = out_;
2771 }
2772
2773 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2774
2775 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2776
2777 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
2778
2779 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
2780
2781 Ok(())
2782 }
2783 }
2784
2785 unsafe impl<___E>
2786 ::fidl_next::EncodeOption<
2787 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2788 ___E,
2789 > for RealmOpenExposedDirRequest
2790 where
2791 ___E: ::fidl_next::Encoder + ?Sized,
2792 RealmOpenExposedDirRequest:
2793 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>,
2794 {
2795 #[inline]
2796 fn encode_option(
2797 this: ::core::option::Option<Self>,
2798 encoder: &mut ___E,
2799 out: &mut ::core::mem::MaybeUninit<
2800 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2801 >,
2802 _: (),
2803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2804 if let Some(inner) = this {
2805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2806 ::fidl_next::wire::Box::encode_present(out);
2807 } else {
2808 ::fidl_next::wire::Box::encode_absent(out);
2809 }
2810
2811 Ok(())
2812 }
2813 }
2814
2815 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenExposedDirRequest<'de>>
2816 for RealmOpenExposedDirRequest
2817 {
2818 #[inline]
2819 fn from_wire(wire: crate::wire::RealmOpenExposedDirRequest<'de>) -> Self {
2820 Self {
2821 child: ::fidl_next::FromWire::from_wire(wire.child),
2822
2823 exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir),
2824 }
2825 }
2826 }
2827
2828 #[derive(Debug, PartialEq)]
2829 pub struct RealmCreateChildRequest {
2830 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2831
2832 pub decl: ::fidl_next_fuchsia_component_decl::natural::Child,
2833
2834 pub args: crate::natural::CreateChildArgs,
2835 }
2836
2837 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
2838 for RealmCreateChildRequest
2839 where
2840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2841 ___E: ::fidl_next::Encoder,
2842 ___E: ::fidl_next::fuchsia::HandleEncoder,
2843 {
2844 #[inline]
2845 fn encode(
2846 self,
2847 encoder_: &mut ___E,
2848 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
2849 _: (),
2850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2851 ::fidl_next::munge! {
2852 let crate::wire::RealmCreateChildRequest {
2853 collection,
2854 decl,
2855 args,
2856
2857 } = out_;
2858 }
2859
2860 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2861
2862 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2863
2864 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
2865
2866 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(decl.as_mut_ptr()) };
2867
2868 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
2869
2870 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
2871
2872 Ok(())
2873 }
2874 }
2875
2876 unsafe impl<___E>
2877 ::fidl_next::EncodeOption<
2878 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2879 ___E,
2880 > for RealmCreateChildRequest
2881 where
2882 ___E: ::fidl_next::Encoder + ?Sized,
2883 RealmCreateChildRequest:
2884 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>,
2885 {
2886 #[inline]
2887 fn encode_option(
2888 this: ::core::option::Option<Self>,
2889 encoder: &mut ___E,
2890 out: &mut ::core::mem::MaybeUninit<
2891 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2892 >,
2893 _: (),
2894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2895 if let Some(inner) = this {
2896 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2897 ::fidl_next::wire::Box::encode_present(out);
2898 } else {
2899 ::fidl_next::wire::Box::encode_absent(out);
2900 }
2901
2902 Ok(())
2903 }
2904 }
2905
2906 impl<'de> ::fidl_next::FromWire<crate::wire::RealmCreateChildRequest<'de>>
2907 for RealmCreateChildRequest
2908 {
2909 #[inline]
2910 fn from_wire(wire: crate::wire::RealmCreateChildRequest<'de>) -> Self {
2911 Self {
2912 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2913
2914 decl: ::fidl_next::FromWire::from_wire(wire.decl),
2915
2916 args: ::fidl_next::FromWire::from_wire(wire.args),
2917 }
2918 }
2919 }
2920
2921 #[derive(Debug, PartialEq)]
2922 pub struct RealmGetResolvedInfoResponse {
2923 pub resolved_info: ::fidl_next_fuchsia_component_resolution::natural::Component,
2924 }
2925
2926 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
2927 for RealmGetResolvedInfoResponse
2928 where
2929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2930 ___E: ::fidl_next::Encoder,
2931 ___E: ::fidl_next::fuchsia::HandleEncoder,
2932 {
2933 #[inline]
2934 fn encode(
2935 self,
2936 encoder_: &mut ___E,
2937 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
2938 _: (),
2939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940 ::fidl_next::munge! {
2941 let crate::wire::RealmGetResolvedInfoResponse {
2942 resolved_info,
2943
2944 } = out_;
2945 }
2946
2947 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
2948
2949 let mut _field =
2950 unsafe { ::fidl_next::Slot::new_unchecked(resolved_info.as_mut_ptr()) };
2951
2952 Ok(())
2953 }
2954 }
2955
2956 unsafe impl<___E>
2957 ::fidl_next::EncodeOption<
2958 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2959 ___E,
2960 > for RealmGetResolvedInfoResponse
2961 where
2962 ___E: ::fidl_next::Encoder + ?Sized,
2963 RealmGetResolvedInfoResponse:
2964 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>,
2965 {
2966 #[inline]
2967 fn encode_option(
2968 this: ::core::option::Option<Self>,
2969 encoder: &mut ___E,
2970 out: &mut ::core::mem::MaybeUninit<
2971 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2972 >,
2973 _: (),
2974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2975 if let Some(inner) = this {
2976 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2977 ::fidl_next::wire::Box::encode_present(out);
2978 } else {
2979 ::fidl_next::wire::Box::encode_absent(out);
2980 }
2981
2982 Ok(())
2983 }
2984 }
2985
2986 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetResolvedInfoResponse<'de>>
2987 for RealmGetResolvedInfoResponse
2988 {
2989 #[inline]
2990 fn from_wire(wire: crate::wire::RealmGetResolvedInfoResponse<'de>) -> Self {
2991 Self { resolved_info: ::fidl_next::FromWire::from_wire(wire.resolved_info) }
2992 }
2993 }
2994
2995 #[derive(Debug, PartialEq)]
2996 pub struct StorageAdminListStorageInRealmRequest {
2997 pub relative_moniker: ::std::string::String,
2998
2999 pub iterator:
3000 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::fuchsia::zx::Channel>,
3001 }
3002
3003 unsafe impl<___E>
3004 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
3005 for StorageAdminListStorageInRealmRequest
3006 where
3007 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3008 ___E: ::fidl_next::Encoder,
3009 ___E: ::fidl_next::fuchsia::HandleEncoder,
3010 {
3011 #[inline]
3012 fn encode(
3013 self,
3014 encoder_: &mut ___E,
3015 out_: &mut ::core::mem::MaybeUninit<
3016 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3017 >,
3018 _: (),
3019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3020 ::fidl_next::munge! {
3021 let crate::wire::StorageAdminListStorageInRealmRequest {
3022 relative_moniker,
3023 iterator,
3024
3025 } = out_;
3026 }
3027
3028 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3029
3030 let mut _field =
3031 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3032 ::fidl_next::Constrained::validate(_field, 4096)?;
3033
3034 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
3035
3036 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
3037
3038 Ok(())
3039 }
3040 }
3041
3042 unsafe impl<___E>
3043 ::fidl_next::EncodeOption<
3044 ::fidl_next::wire::Box<
3045 'static,
3046 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3047 >,
3048 ___E,
3049 > for StorageAdminListStorageInRealmRequest
3050 where
3051 ___E: ::fidl_next::Encoder + ?Sized,
3052 StorageAdminListStorageInRealmRequest:
3053 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>,
3054 {
3055 #[inline]
3056 fn encode_option(
3057 this: ::core::option::Option<Self>,
3058 encoder: &mut ___E,
3059 out: &mut ::core::mem::MaybeUninit<
3060 ::fidl_next::wire::Box<
3061 'static,
3062 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3063 >,
3064 >,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067 if let Some(inner) = this {
3068 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3069 ::fidl_next::wire::Box::encode_present(out);
3070 } else {
3071 ::fidl_next::wire::Box::encode_absent(out);
3072 }
3073
3074 Ok(())
3075 }
3076 }
3077
3078 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminListStorageInRealmRequest<'de>>
3079 for StorageAdminListStorageInRealmRequest
3080 {
3081 #[inline]
3082 fn from_wire(wire: crate::wire::StorageAdminListStorageInRealmRequest<'de>) -> Self {
3083 Self {
3084 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3085
3086 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
3087 }
3088 }
3089 }
3090
3091 #[derive(Debug, PartialEq)]
3092 pub struct StorageAdminOpenStorageRequest {
3093 pub relative_moniker: ::std::string::String,
3094
3095 pub object:
3096 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3097 }
3098
3099 unsafe impl<___E>
3100 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
3101 for StorageAdminOpenStorageRequest
3102 where
3103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3104 ___E: ::fidl_next::Encoder,
3105 ___E: ::fidl_next::fuchsia::HandleEncoder,
3106 {
3107 #[inline]
3108 fn encode(
3109 self,
3110 encoder_: &mut ___E,
3111 out_: &mut ::core::mem::MaybeUninit<
3112 crate::wire::StorageAdminOpenStorageRequest<'static>,
3113 >,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::StorageAdminOpenStorageRequest {
3118 relative_moniker,
3119 object,
3120
3121 } = out_;
3122 }
3123
3124 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3125
3126 let mut _field =
3127 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3128 ::fidl_next::Constrained::validate(_field, 4096)?;
3129
3130 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3131
3132 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3133
3134 Ok(())
3135 }
3136 }
3137
3138 unsafe impl<___E>
3139 ::fidl_next::EncodeOption<
3140 ::fidl_next::wire::Box<'static, crate::wire::StorageAdminOpenStorageRequest<'static>>,
3141 ___E,
3142 > for StorageAdminOpenStorageRequest
3143 where
3144 ___E: ::fidl_next::Encoder + ?Sized,
3145 StorageAdminOpenStorageRequest:
3146 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>,
3147 {
3148 #[inline]
3149 fn encode_option(
3150 this: ::core::option::Option<Self>,
3151 encoder: &mut ___E,
3152 out: &mut ::core::mem::MaybeUninit<
3153 ::fidl_next::wire::Box<
3154 'static,
3155 crate::wire::StorageAdminOpenStorageRequest<'static>,
3156 >,
3157 >,
3158 _: (),
3159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3160 if let Some(inner) = this {
3161 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3162 ::fidl_next::wire::Box::encode_present(out);
3163 } else {
3164 ::fidl_next::wire::Box::encode_absent(out);
3165 }
3166
3167 Ok(())
3168 }
3169 }
3170
3171 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenStorageRequest<'de>>
3172 for StorageAdminOpenStorageRequest
3173 {
3174 #[inline]
3175 fn from_wire(wire: crate::wire::StorageAdminOpenStorageRequest<'de>) -> Self {
3176 Self {
3177 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3178
3179 object: ::fidl_next::FromWire::from_wire(wire.object),
3180 }
3181 }
3182 }
3183
3184 #[derive(Debug, PartialEq)]
3185 pub struct StorageAdminOpenComponentStorageByIdRequest {
3186 pub id: ::std::string::String,
3187
3188 pub object:
3189 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3190 }
3191
3192 unsafe impl<___E>
3193 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
3194 for StorageAdminOpenComponentStorageByIdRequest
3195 where
3196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3197 ___E: ::fidl_next::Encoder,
3198 ___E: ::fidl_next::fuchsia::HandleEncoder,
3199 {
3200 #[inline]
3201 fn encode(
3202 self,
3203 encoder_: &mut ___E,
3204 out_: &mut ::core::mem::MaybeUninit<
3205 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3206 >,
3207 _: (),
3208 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3209 ::fidl_next::munge! {
3210 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
3211 id,
3212 object,
3213
3214 } = out_;
3215 }
3216
3217 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
3218
3219 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3220 ::fidl_next::Constrained::validate(_field, 64)?;
3221
3222 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3223
3224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3225
3226 Ok(())
3227 }
3228 }
3229
3230 unsafe impl<___E>
3231 ::fidl_next::EncodeOption<
3232 ::fidl_next::wire::Box<
3233 'static,
3234 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3235 >,
3236 ___E,
3237 > for StorageAdminOpenComponentStorageByIdRequest
3238 where
3239 ___E: ::fidl_next::Encoder + ?Sized,
3240 StorageAdminOpenComponentStorageByIdRequest: ::fidl_next::Encode<
3241 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3242 ___E,
3243 >,
3244 {
3245 #[inline]
3246 fn encode_option(
3247 this: ::core::option::Option<Self>,
3248 encoder: &mut ___E,
3249 out: &mut ::core::mem::MaybeUninit<
3250 ::fidl_next::wire::Box<
3251 'static,
3252 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3253 >,
3254 >,
3255 _: (),
3256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3257 if let Some(inner) = this {
3258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3259 ::fidl_next::wire::Box::encode_present(out);
3260 } else {
3261 ::fidl_next::wire::Box::encode_absent(out);
3262 }
3263
3264 Ok(())
3265 }
3266 }
3267
3268 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>>
3269 for StorageAdminOpenComponentStorageByIdRequest
3270 {
3271 #[inline]
3272 fn from_wire(wire: crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>) -> Self {
3273 Self {
3274 id: ::fidl_next::FromWire::from_wire(wire.id),
3275
3276 object: ::fidl_next::FromWire::from_wire(wire.object),
3277 }
3278 }
3279 }
3280}
3281
3282pub mod wire {
3283
3284 pub use fidl_next_common_fuchsia_component::wire::*;
3285
3286 #[repr(C)]
3288 pub struct CapabilityRequestedPayload<'de> {
3289 pub(crate) table: ::fidl_next::wire::Table<'de>,
3290 }
3291
3292 impl<'de> Drop for CapabilityRequestedPayload<'de> {
3293 fn drop(&mut self) {
3294 let _ = self.table.get(1).map(|envelope| unsafe {
3295 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3296 });
3297
3298 let _ = self.table.get(2).map(|envelope| unsafe {
3299 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3300 });
3301 }
3302 }
3303
3304 impl ::fidl_next::Constrained for CapabilityRequestedPayload<'_> {
3305 type Constraint = ();
3306
3307 fn validate(
3308 _: ::fidl_next::Slot<'_, Self>,
3309 _: Self::Constraint,
3310 ) -> Result<(), ::fidl_next::ValidationError> {
3311 Ok(())
3312 }
3313 }
3314
3315 unsafe impl ::fidl_next::Wire for CapabilityRequestedPayload<'static> {
3316 type Narrowed<'de> = CapabilityRequestedPayload<'de>;
3317
3318 #[inline]
3319 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3320 ::fidl_next::munge!(let Self { table } = out);
3321 ::fidl_next::wire::Table::zero_padding(table);
3322 }
3323 }
3324
3325 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityRequestedPayload<'de>
3326 where
3327 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3328 ___D: ::fidl_next::fuchsia::HandleDecoder,
3329 {
3330 fn decode(
3331 slot: ::fidl_next::Slot<'_, Self>,
3332 decoder: &mut ___D,
3333 _: (),
3334 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3335 ::fidl_next::munge!(let Self { table } = slot);
3336
3337 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3338 match ordinal {
3339 0 => unsafe { ::core::hint::unreachable_unchecked() },
3340
3341 1 => {
3342 ::fidl_next::wire::Envelope::decode_as::<
3343 ___D,
3344 ::fidl_next::wire::String<'de>,
3345 >(slot.as_mut(), decoder, 255)?;
3346
3347 let value = unsafe {
3348 slot.deref_unchecked()
3349 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3350 };
3351
3352 if value.len() > 255 {
3353 return Err(::fidl_next::DecodeError::VectorTooLong {
3354 size: value.len() as u64,
3355 limit: 255,
3356 });
3357 }
3358
3359 Ok(())
3360 }
3361
3362 2 => {
3363 ::fidl_next::wire::Envelope::decode_as::<
3364 ___D,
3365 ::fidl_next::wire::fuchsia::Channel,
3366 >(slot.as_mut(), decoder, ())?;
3367
3368 Ok(())
3369 }
3370
3371 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3372 }
3373 })
3374 }
3375 }
3376
3377 impl<'de> CapabilityRequestedPayload<'de> {
3378 pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3379 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3380 }
3381
3382 pub fn take_name(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3383 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3384 }
3385
3386 pub fn capability(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
3387 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3388 }
3389
3390 pub fn take_capability(
3391 &mut self,
3392 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Channel> {
3393 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3394 }
3395 }
3396
3397 impl<'de> ::core::fmt::Debug for CapabilityRequestedPayload<'de> {
3398 fn fmt(
3399 &self,
3400 f: &mut ::core::fmt::Formatter<'_>,
3401 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3402 f.debug_struct("CapabilityRequestedPayload")
3403 .field("name", &self.name())
3404 .field("capability", &self.capability())
3405 .finish()
3406 }
3407 }
3408
3409 impl<'de> ::fidl_next::IntoNatural for CapabilityRequestedPayload<'de> {
3410 type Natural = crate::natural::CapabilityRequestedPayload;
3411 }
3412
3413 #[derive(Debug)]
3415 #[repr(C)]
3416 pub struct ControllerIsStartedResponse {
3417 pub is_started: bool,
3418 }
3419
3420 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerIsStartedResponse>(), 1);
3421 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerIsStartedResponse>(), 1);
3422
3423 static_assertions::const_assert_eq!(
3424 std::mem::offset_of!(ControllerIsStartedResponse, is_started),
3425 0
3426 );
3427
3428 impl ::fidl_next::Constrained for ControllerIsStartedResponse {
3429 type Constraint = ();
3430
3431 fn validate(
3432 _: ::fidl_next::Slot<'_, Self>,
3433 _: Self::Constraint,
3434 ) -> Result<(), ::fidl_next::ValidationError> {
3435 Ok(())
3436 }
3437 }
3438
3439 unsafe impl ::fidl_next::Wire for ControllerIsStartedResponse {
3440 type Narrowed<'de> = ControllerIsStartedResponse;
3441
3442 #[inline]
3443 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3444 ::fidl_next::munge! {
3445 let Self {
3446 is_started,
3447
3448 } = &mut *out_;
3449 }
3450
3451 ::fidl_next::Wire::zero_padding(is_started);
3452 }
3453 }
3454
3455 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerIsStartedResponse
3456 where
3457 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3458 ___D: ::fidl_next::fuchsia::HandleDecoder,
3459 {
3460 fn decode(
3461 slot_: ::fidl_next::Slot<'_, Self>,
3462 decoder_: &mut ___D,
3463 _: (),
3464 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3465 ::fidl_next::munge! {
3466 let Self {
3467 mut is_started,
3468
3469 } = slot_;
3470 }
3471
3472 let _field = is_started.as_mut();
3473
3474 ::fidl_next::Decode::decode(is_started.as_mut(), decoder_, ())?;
3475
3476 Ok(())
3477 }
3478 }
3479
3480 impl ::fidl_next::IntoNatural for ControllerIsStartedResponse {
3481 type Natural = crate::natural::ControllerIsStartedResponse;
3482 }
3483
3484 #[derive(Debug)]
3486 #[repr(C)]
3487 pub struct ControllerGetExposedDictionaryResponse {
3488 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3489 }
3490
3491 static_assertions::const_assert_eq!(
3492 std::mem::size_of::<ControllerGetExposedDictionaryResponse>(),
3493 4
3494 );
3495 static_assertions::const_assert_eq!(
3496 std::mem::align_of::<ControllerGetExposedDictionaryResponse>(),
3497 4
3498 );
3499
3500 static_assertions::const_assert_eq!(
3501 std::mem::offset_of!(ControllerGetExposedDictionaryResponse, dictionary),
3502 0
3503 );
3504
3505 impl ::fidl_next::Constrained for ControllerGetExposedDictionaryResponse {
3506 type Constraint = ();
3507
3508 fn validate(
3509 _: ::fidl_next::Slot<'_, Self>,
3510 _: Self::Constraint,
3511 ) -> Result<(), ::fidl_next::ValidationError> {
3512 Ok(())
3513 }
3514 }
3515
3516 unsafe impl ::fidl_next::Wire for ControllerGetExposedDictionaryResponse {
3517 type Narrowed<'de> = ControllerGetExposedDictionaryResponse;
3518
3519 #[inline]
3520 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3521 ::fidl_next::munge! {
3522 let Self {
3523 dictionary,
3524
3525 } = &mut *out_;
3526 }
3527
3528 ::fidl_next::Wire::zero_padding(dictionary);
3529 }
3530 }
3531
3532 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetExposedDictionaryResponse
3533 where
3534 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3535 ___D: ::fidl_next::fuchsia::HandleDecoder,
3536 {
3537 fn decode(
3538 slot_: ::fidl_next::Slot<'_, Self>,
3539 decoder_: &mut ___D,
3540 _: (),
3541 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3542 ::fidl_next::munge! {
3543 let Self {
3544 mut dictionary,
3545
3546 } = slot_;
3547 }
3548
3549 let _field = dictionary.as_mut();
3550
3551 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3552
3553 Ok(())
3554 }
3555 }
3556
3557 impl ::fidl_next::IntoNatural for ControllerGetExposedDictionaryResponse {
3558 type Natural = crate::natural::ControllerGetExposedDictionaryResponse;
3559 }
3560
3561 #[derive(Debug)]
3563 #[repr(C)]
3564 pub struct ControllerGetOutputDictionaryResponse {
3565 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
3566 }
3567
3568 static_assertions::const_assert_eq!(
3569 std::mem::size_of::<ControllerGetOutputDictionaryResponse>(),
3570 4
3571 );
3572 static_assertions::const_assert_eq!(
3573 std::mem::align_of::<ControllerGetOutputDictionaryResponse>(),
3574 4
3575 );
3576
3577 static_assertions::const_assert_eq!(
3578 std::mem::offset_of!(ControllerGetOutputDictionaryResponse, dictionary),
3579 0
3580 );
3581
3582 impl ::fidl_next::Constrained for ControllerGetOutputDictionaryResponse {
3583 type Constraint = ();
3584
3585 fn validate(
3586 _: ::fidl_next::Slot<'_, Self>,
3587 _: Self::Constraint,
3588 ) -> Result<(), ::fidl_next::ValidationError> {
3589 Ok(())
3590 }
3591 }
3592
3593 unsafe impl ::fidl_next::Wire for ControllerGetOutputDictionaryResponse {
3594 type Narrowed<'de> = ControllerGetOutputDictionaryResponse;
3595
3596 #[inline]
3597 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3598 ::fidl_next::munge! {
3599 let Self {
3600 dictionary,
3601
3602 } = &mut *out_;
3603 }
3604
3605 ::fidl_next::Wire::zero_padding(dictionary);
3606 }
3607 }
3608
3609 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetOutputDictionaryResponse
3610 where
3611 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3612 ___D: ::fidl_next::fuchsia::HandleDecoder,
3613 {
3614 fn decode(
3615 slot_: ::fidl_next::Slot<'_, Self>,
3616 decoder_: &mut ___D,
3617 _: (),
3618 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3619 ::fidl_next::munge! {
3620 let Self {
3621 mut dictionary,
3622
3623 } = slot_;
3624 }
3625
3626 let _field = dictionary.as_mut();
3627
3628 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3629
3630 Ok(())
3631 }
3632 }
3633
3634 impl ::fidl_next::IntoNatural for ControllerGetOutputDictionaryResponse {
3635 type Natural = crate::natural::ControllerGetOutputDictionaryResponse;
3636 }
3637
3638 #[repr(C)]
3640 pub struct NamespaceEntry<'de> {
3641 pub(crate) table: ::fidl_next::wire::Table<'de>,
3642 }
3643
3644 impl<'de> Drop for NamespaceEntry<'de> {
3645 fn drop(&mut self) {
3646 let _ = self.table.get(1).map(|envelope| unsafe {
3647 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3648 });
3649
3650 let _ = self.table.get(2).map(|envelope| unsafe {
3651 envelope.read_unchecked::<::fidl_next::ClientEnd<
3652 ::fidl_next_fuchsia_io::Directory,
3653 ::fidl_next::wire::fuchsia::Channel,
3654 >>()
3655 });
3656 }
3657 }
3658
3659 impl ::fidl_next::Constrained for NamespaceEntry<'_> {
3660 type Constraint = ();
3661
3662 fn validate(
3663 _: ::fidl_next::Slot<'_, Self>,
3664 _: Self::Constraint,
3665 ) -> Result<(), ::fidl_next::ValidationError> {
3666 Ok(())
3667 }
3668 }
3669
3670 unsafe impl ::fidl_next::Wire for NamespaceEntry<'static> {
3671 type Narrowed<'de> = NamespaceEntry<'de>;
3672
3673 #[inline]
3674 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3675 ::fidl_next::munge!(let Self { table } = out);
3676 ::fidl_next::wire::Table::zero_padding(table);
3677 }
3678 }
3679
3680 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceEntry<'de>
3681 where
3682 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3683 ___D: ::fidl_next::fuchsia::HandleDecoder,
3684 {
3685 fn decode(
3686 slot: ::fidl_next::Slot<'_, Self>,
3687 decoder: &mut ___D,
3688 _: (),
3689 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3690 ::fidl_next::munge!(let Self { table } = slot);
3691
3692 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3693 match ordinal {
3694 0 => unsafe { ::core::hint::unreachable_unchecked() },
3695
3696 1 => {
3697 ::fidl_next::wire::Envelope::decode_as::<
3698 ___D,
3699 ::fidl_next::wire::String<'de>,
3700 >(slot.as_mut(), decoder, 4095)?;
3701
3702 let value = unsafe {
3703 slot.deref_unchecked()
3704 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3705 };
3706
3707 if value.len() > 4095 {
3708 return Err(::fidl_next::DecodeError::VectorTooLong {
3709 size: value.len() as u64,
3710 limit: 4095,
3711 });
3712 }
3713
3714 Ok(())
3715 }
3716
3717 2 => {
3718 ::fidl_next::wire::Envelope::decode_as::<
3719 ___D,
3720 ::fidl_next::ClientEnd<
3721 ::fidl_next_fuchsia_io::Directory,
3722 ::fidl_next::wire::fuchsia::Channel,
3723 >,
3724 >(slot.as_mut(), decoder, ())?;
3725
3726 Ok(())
3727 }
3728
3729 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3730 }
3731 })
3732 }
3733 }
3734
3735 impl<'de> NamespaceEntry<'de> {
3736 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3737 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3738 }
3739
3740 pub fn take_path(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3741 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3742 }
3743
3744 pub fn directory(
3745 &self,
3746 ) -> ::core::option::Option<
3747 &::fidl_next::ClientEnd<
3748 ::fidl_next_fuchsia_io::Directory,
3749 ::fidl_next::wire::fuchsia::Channel,
3750 >,
3751 > {
3752 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3753 }
3754
3755 pub fn take_directory(
3756 &mut self,
3757 ) -> ::core::option::Option<
3758 ::fidl_next::ClientEnd<
3759 ::fidl_next_fuchsia_io::Directory,
3760 ::fidl_next::wire::fuchsia::Channel,
3761 >,
3762 > {
3763 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3764 }
3765 }
3766
3767 impl<'de> ::core::fmt::Debug for NamespaceEntry<'de> {
3768 fn fmt(
3769 &self,
3770 f: &mut ::core::fmt::Formatter<'_>,
3771 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3772 f.debug_struct("NamespaceEntry")
3773 .field("path", &self.path())
3774 .field("directory", &self.directory())
3775 .finish()
3776 }
3777 }
3778
3779 impl<'de> ::fidl_next::IntoNatural for NamespaceEntry<'de> {
3780 type Natural = crate::natural::NamespaceEntry;
3781 }
3782
3783 #[repr(C)]
3785 pub struct StartChildArgs<'de> {
3786 pub(crate) table: ::fidl_next::wire::Table<'de>,
3787 }
3788
3789 impl<'de> Drop for StartChildArgs<'de> {
3790 fn drop(&mut self) {
3791 let _ = self.table.get(1).map(|envelope| unsafe {
3792 envelope.read_unchecked::<::fidl_next::wire::Vector<
3793 'de,
3794 ::fidl_next_fuchsia_process::wire::HandleInfo,
3795 >>()
3796 });
3797
3798 let _ = self.table.get(2)
3799 .map(|envelope| unsafe {
3800 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>()
3801 });
3802
3803 let _ = self.table.get(3)
3804 .map(|envelope| unsafe {
3805 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
3806 });
3807
3808 let _ = self.table.get(4).map(|envelope| unsafe {
3809 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
3810 });
3811 }
3812 }
3813
3814 impl ::fidl_next::Constrained for StartChildArgs<'_> {
3815 type Constraint = ();
3816
3817 fn validate(
3818 _: ::fidl_next::Slot<'_, Self>,
3819 _: Self::Constraint,
3820 ) -> Result<(), ::fidl_next::ValidationError> {
3821 Ok(())
3822 }
3823 }
3824
3825 unsafe impl ::fidl_next::Wire for StartChildArgs<'static> {
3826 type Narrowed<'de> = StartChildArgs<'de>;
3827
3828 #[inline]
3829 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3830 ::fidl_next::munge!(let Self { table } = out);
3831 ::fidl_next::wire::Table::zero_padding(table);
3832 }
3833 }
3834
3835 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartChildArgs<'de>
3836 where
3837 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3838 ___D: ::fidl_next::fuchsia::HandleDecoder,
3839 {
3840 fn decode(
3841 slot: ::fidl_next::Slot<'_, Self>,
3842 decoder: &mut ___D,
3843 _: (),
3844 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3845 ::fidl_next::munge!(let Self { table } = slot);
3846
3847 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3848 match ordinal {
3849 0 => unsafe { ::core::hint::unreachable_unchecked() },
3850
3851 1 => {
3852 ::fidl_next::wire::Envelope::decode_as::<
3853 ___D,
3854 ::fidl_next::wire::Vector<
3855 'de,
3856 ::fidl_next_fuchsia_process::wire::HandleInfo,
3857 >,
3858 >(slot.as_mut(), decoder, (128, ()))?;
3859
3860 let value = unsafe {
3861 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
3862 '_,
3863 ::fidl_next_fuchsia_process::wire::HandleInfo,
3864 >>()
3865 };
3866
3867 if value.len() > 128 {
3868 return Err(::fidl_next::DecodeError::VectorTooLong {
3869 size: value.len() as u64,
3870 limit: 128,
3871 });
3872 }
3873
3874 Ok(())
3875 }
3876
3877 2 => {
3878 ::fidl_next::wire::Envelope::decode_as::<
3879 ___D,
3880 ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
3881 >(slot.as_mut(), decoder, (32, ()))?;
3882
3883 let value = unsafe {
3884 slot
3885 .deref_unchecked()
3886 .deref_unchecked::<
3887 ::fidl_next::wire::Vector<'_, crate::wire::NamespaceEntry<'_>>
3888 >()
3889 };
3890
3891 if value.len() > 32 {
3892 return Err(::fidl_next::DecodeError::VectorTooLong {
3893 size: value.len() as u64,
3894 limit: 32,
3895 });
3896 }
3897
3898 Ok(())
3899 }
3900
3901 3 => {
3902 ::fidl_next::wire::Envelope::decode_as::<
3903 ___D,
3904 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3905 >(slot.as_mut(), decoder, ())?;
3906
3907 Ok(())
3908 }
3909
3910 4 => {
3911 ::fidl_next::wire::Envelope::decode_as::<
3912 ___D,
3913 ::fidl_next::wire::fuchsia::EventPair,
3914 >(slot.as_mut(), decoder, ())?;
3915
3916 Ok(())
3917 }
3918
3919 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3920 }
3921 })
3922 }
3923 }
3924
3925 impl<'de> StartChildArgs<'de> {
3926 pub fn numbered_handles(
3927 &self,
3928 ) -> ::core::option::Option<
3929 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3930 > {
3931 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3932 }
3933
3934 pub fn take_numbered_handles(
3935 &mut self,
3936 ) -> ::core::option::Option<
3937 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3938 > {
3939 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3940 }
3941
3942 pub fn namespace_entries(
3943 &self,
3944 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3945 {
3946 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3947 }
3948
3949 pub fn take_namespace_entries(
3950 &mut self,
3951 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3952 {
3953 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3954 }
3955
3956 pub fn dictionary(
3957 &self,
3958 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3959 {
3960 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3961 }
3962
3963 pub fn take_dictionary(
3964 &mut self,
3965 ) -> ::core::option::Option<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3966 {
3967 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3968 }
3969
3970 pub fn additional_inputs(
3971 &self,
3972 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
3973 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3974 }
3975
3976 pub fn take_additional_inputs(
3977 &mut self,
3978 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
3979 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3980 }
3981 }
3982
3983 impl<'de> ::core::fmt::Debug for StartChildArgs<'de> {
3984 fn fmt(
3985 &self,
3986 f: &mut ::core::fmt::Formatter<'_>,
3987 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3988 f.debug_struct("StartChildArgs")
3989 .field("numbered_handles", &self.numbered_handles())
3990 .field("namespace_entries", &self.namespace_entries())
3991 .field("dictionary", &self.dictionary())
3992 .field("additional_inputs", &self.additional_inputs())
3993 .finish()
3994 }
3995 }
3996
3997 impl<'de> ::fidl_next::IntoNatural for StartChildArgs<'de> {
3998 type Natural = crate::natural::StartChildArgs;
3999 }
4000
4001 #[derive(Debug)]
4003 #[repr(C)]
4004 pub struct ControllerStartRequest<'de> {
4005 pub args: crate::wire::StartChildArgs<'de>,
4006
4007 pub execution_controller:
4008 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::wire::fuchsia::Channel>,
4009 }
4010
4011 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerStartRequest<'_>>(), 24);
4012 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerStartRequest<'_>>(), 8);
4013
4014 static_assertions::const_assert_eq!(std::mem::offset_of!(ControllerStartRequest<'_>, args), 0);
4015
4016 static_assertions::const_assert_eq!(
4017 std::mem::offset_of!(ControllerStartRequest<'_>, execution_controller),
4018 16
4019 );
4020
4021 impl ::fidl_next::Constrained for ControllerStartRequest<'_> {
4022 type Constraint = ();
4023
4024 fn validate(
4025 _: ::fidl_next::Slot<'_, Self>,
4026 _: Self::Constraint,
4027 ) -> Result<(), ::fidl_next::ValidationError> {
4028 Ok(())
4029 }
4030 }
4031
4032 unsafe impl ::fidl_next::Wire for ControllerStartRequest<'static> {
4033 type Narrowed<'de> = ControllerStartRequest<'de>;
4034
4035 #[inline]
4036 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4037 ::fidl_next::munge! {
4038 let Self {
4039 args,
4040 execution_controller,
4041
4042 } = &mut *out_;
4043 }
4044
4045 ::fidl_next::Wire::zero_padding(args);
4046
4047 ::fidl_next::Wire::zero_padding(execution_controller);
4048
4049 unsafe {
4050 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4051 }
4052 }
4053 }
4054
4055 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ControllerStartRequest<'de>
4056 where
4057 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4058 ___D: ::fidl_next::Decoder<'de>,
4059 ___D: ::fidl_next::fuchsia::HandleDecoder,
4060 {
4061 fn decode(
4062 slot_: ::fidl_next::Slot<'_, Self>,
4063 decoder_: &mut ___D,
4064 _: (),
4065 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4066 if slot_.as_bytes()[20..24] != [0u8; 4] {
4067 return Err(::fidl_next::DecodeError::InvalidPadding);
4068 }
4069
4070 ::fidl_next::munge! {
4071 let Self {
4072 mut args,
4073 mut execution_controller,
4074
4075 } = slot_;
4076 }
4077
4078 let _field = args.as_mut();
4079
4080 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
4081
4082 let _field = execution_controller.as_mut();
4083
4084 ::fidl_next::Decode::decode(execution_controller.as_mut(), decoder_, ())?;
4085
4086 Ok(())
4087 }
4088 }
4089
4090 impl<'de> ::fidl_next::IntoNatural for ControllerStartRequest<'de> {
4091 type Natural = crate::natural::ControllerStartRequest;
4092 }
4093
4094 #[derive(Debug)]
4096 #[repr(C)]
4097 pub struct ControllerOpenExposedDirRequest {
4098 pub exposed_dir: ::fidl_next::ServerEnd<
4099 ::fidl_next_fuchsia_io::Directory,
4100 ::fidl_next::wire::fuchsia::Channel,
4101 >,
4102 }
4103
4104 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerOpenExposedDirRequest>(), 4);
4105 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerOpenExposedDirRequest>(), 4);
4106
4107 static_assertions::const_assert_eq!(
4108 std::mem::offset_of!(ControllerOpenExposedDirRequest, exposed_dir),
4109 0
4110 );
4111
4112 impl ::fidl_next::Constrained for ControllerOpenExposedDirRequest {
4113 type Constraint = ();
4114
4115 fn validate(
4116 _: ::fidl_next::Slot<'_, Self>,
4117 _: Self::Constraint,
4118 ) -> Result<(), ::fidl_next::ValidationError> {
4119 Ok(())
4120 }
4121 }
4122
4123 unsafe impl ::fidl_next::Wire for ControllerOpenExposedDirRequest {
4124 type Narrowed<'de> = ControllerOpenExposedDirRequest;
4125
4126 #[inline]
4127 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4128 ::fidl_next::munge! {
4129 let Self {
4130 exposed_dir,
4131
4132 } = &mut *out_;
4133 }
4134
4135 ::fidl_next::Wire::zero_padding(exposed_dir);
4136 }
4137 }
4138
4139 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerOpenExposedDirRequest
4140 where
4141 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4142 ___D: ::fidl_next::fuchsia::HandleDecoder,
4143 {
4144 fn decode(
4145 slot_: ::fidl_next::Slot<'_, Self>,
4146 decoder_: &mut ___D,
4147 _: (),
4148 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4149 ::fidl_next::munge! {
4150 let Self {
4151 mut exposed_dir,
4152
4153 } = slot_;
4154 }
4155
4156 let _field = exposed_dir.as_mut();
4157
4158 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
4159
4160 Ok(())
4161 }
4162 }
4163
4164 impl ::fidl_next::IntoNatural for ControllerOpenExposedDirRequest {
4165 type Natural = crate::natural::ControllerOpenExposedDirRequest;
4166 }
4167
4168 #[repr(C)]
4170 pub struct CreateChildArgs<'de> {
4171 pub(crate) table: ::fidl_next::wire::Table<'de>,
4172 }
4173
4174 impl<'de> Drop for CreateChildArgs<'de> {
4175 fn drop(&mut self) {
4176 let _ = self.table.get(1).map(|envelope| unsafe {
4177 envelope.read_unchecked::<::fidl_next::wire::Vector<
4178 'de,
4179 ::fidl_next_fuchsia_process::wire::HandleInfo,
4180 >>()
4181 });
4182
4183 let _ = self.table.get(2).map(|envelope| unsafe {
4184 envelope.read_unchecked::<::fidl_next::wire::Vector<
4185 'de,
4186 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4187 >>()
4188 });
4189
4190 let _ = self.table.get(3).map(|envelope| unsafe {
4191 envelope.read_unchecked::<::fidl_next::ServerEnd<
4192 crate::Controller,
4193 ::fidl_next::wire::fuchsia::Channel,
4194 >>()
4195 });
4196
4197 let _ = self.table.get(4)
4198 .map(|envelope| unsafe {
4199 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
4200 });
4201
4202 let _ = self.table.get(5).map(|envelope| unsafe {
4203 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4204 });
4205 }
4206 }
4207
4208 impl ::fidl_next::Constrained for CreateChildArgs<'_> {
4209 type Constraint = ();
4210
4211 fn validate(
4212 _: ::fidl_next::Slot<'_, Self>,
4213 _: Self::Constraint,
4214 ) -> Result<(), ::fidl_next::ValidationError> {
4215 Ok(())
4216 }
4217 }
4218
4219 unsafe impl ::fidl_next::Wire for CreateChildArgs<'static> {
4220 type Narrowed<'de> = CreateChildArgs<'de>;
4221
4222 #[inline]
4223 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4224 ::fidl_next::munge!(let Self { table } = out);
4225 ::fidl_next::wire::Table::zero_padding(table);
4226 }
4227 }
4228
4229 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateChildArgs<'de>
4230 where
4231 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4232 ___D: ::fidl_next::fuchsia::HandleDecoder,
4233 {
4234 fn decode(
4235 slot: ::fidl_next::Slot<'_, Self>,
4236 decoder: &mut ___D,
4237 _: (),
4238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4239 ::fidl_next::munge!(let Self { table } = slot);
4240
4241 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4242 match ordinal {
4243 0 => unsafe { ::core::hint::unreachable_unchecked() },
4244
4245 1 => {
4246 ::fidl_next::wire::Envelope::decode_as::<
4247 ___D,
4248 ::fidl_next::wire::Vector<
4249 'de,
4250 ::fidl_next_fuchsia_process::wire::HandleInfo,
4251 >,
4252 >(slot.as_mut(), decoder, (128, ()))?;
4253
4254 let value = unsafe {
4255 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4256 '_,
4257 ::fidl_next_fuchsia_process::wire::HandleInfo,
4258 >>()
4259 };
4260
4261 if value.len() > 128 {
4262 return Err(::fidl_next::DecodeError::VectorTooLong {
4263 size: value.len() as u64,
4264 limit: 128,
4265 });
4266 }
4267
4268 Ok(())
4269 }
4270
4271 2 => {
4272 ::fidl_next::wire::Envelope::decode_as::<
4273 ___D,
4274 ::fidl_next::wire::Vector<
4275 'de,
4276 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4277 >,
4278 >(slot.as_mut(), decoder, (128, ()))?;
4279
4280 let value = unsafe {
4281 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4282 '_,
4283 ::fidl_next_fuchsia_component_decl::wire::Offer<'_>,
4284 >>()
4285 };
4286
4287 if value.len() > 128 {
4288 return Err(::fidl_next::DecodeError::VectorTooLong {
4289 size: value.len() as u64,
4290 limit: 128,
4291 });
4292 }
4293
4294 Ok(())
4295 }
4296
4297 3 => {
4298 ::fidl_next::wire::Envelope::decode_as::<
4299 ___D,
4300 ::fidl_next::ServerEnd<
4301 crate::Controller,
4302 ::fidl_next::wire::fuchsia::Channel,
4303 >,
4304 >(slot.as_mut(), decoder, ())?;
4305
4306 Ok(())
4307 }
4308
4309 4 => {
4310 ::fidl_next::wire::Envelope::decode_as::<
4311 ___D,
4312 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
4313 >(slot.as_mut(), decoder, ())?;
4314
4315 Ok(())
4316 }
4317
4318 5 => {
4319 ::fidl_next::wire::Envelope::decode_as::<
4320 ___D,
4321 ::fidl_next::wire::fuchsia::EventPair,
4322 >(slot.as_mut(), decoder, ())?;
4323
4324 Ok(())
4325 }
4326
4327 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4328 }
4329 })
4330 }
4331 }
4332
4333 impl<'de> CreateChildArgs<'de> {
4334 pub fn numbered_handles(
4335 &self,
4336 ) -> ::core::option::Option<
4337 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4338 > {
4339 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4340 }
4341
4342 pub fn take_numbered_handles(
4343 &mut self,
4344 ) -> ::core::option::Option<
4345 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4346 > {
4347 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4348 }
4349
4350 pub fn dynamic_offers(
4351 &self,
4352 ) -> ::core::option::Option<
4353 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4354 > {
4355 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4356 }
4357
4358 pub fn take_dynamic_offers(
4359 &mut self,
4360 ) -> ::core::option::Option<
4361 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4362 > {
4363 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4364 }
4365
4366 pub fn controller(
4367 &self,
4368 ) -> ::core::option::Option<
4369 &::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4370 > {
4371 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4372 }
4373
4374 pub fn take_controller(
4375 &mut self,
4376 ) -> ::core::option::Option<
4377 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4378 > {
4379 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
4380 }
4381
4382 pub fn dictionary(
4383 &self,
4384 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4385 {
4386 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4387 }
4388
4389 pub fn take_dictionary(
4390 &mut self,
4391 ) -> ::core::option::Option<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4392 {
4393 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
4394 }
4395
4396 pub fn additional_inputs(
4397 &self,
4398 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4399 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
4400 }
4401
4402 pub fn take_additional_inputs(
4403 &mut self,
4404 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
4405 unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
4406 }
4407 }
4408
4409 impl<'de> ::core::fmt::Debug for CreateChildArgs<'de> {
4410 fn fmt(
4411 &self,
4412 f: &mut ::core::fmt::Formatter<'_>,
4413 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4414 f.debug_struct("CreateChildArgs")
4415 .field("numbered_handles", &self.numbered_handles())
4416 .field("dynamic_offers", &self.dynamic_offers())
4417 .field("controller", &self.controller())
4418 .field("dictionary", &self.dictionary())
4419 .field("additional_inputs", &self.additional_inputs())
4420 .finish()
4421 }
4422 }
4423
4424 impl<'de> ::fidl_next::IntoNatural for CreateChildArgs<'de> {
4425 type Natural = crate::natural::CreateChildArgs;
4426 }
4427
4428 #[repr(C)]
4430 pub struct DebugStartedPayload<'de> {
4431 pub(crate) table: ::fidl_next::wire::Table<'de>,
4432 }
4433
4434 impl<'de> Drop for DebugStartedPayload<'de> {
4435 fn drop(&mut self) {
4436 let _ = self.table.get(1).map(|envelope| unsafe {
4437 envelope.read_unchecked::<::fidl_next::ClientEnd<
4438 ::fidl_next_fuchsia_io::Directory,
4439 ::fidl_next::wire::fuchsia::Channel,
4440 >>()
4441 });
4442
4443 let _ = self.table.get(2).map(|envelope| unsafe {
4444 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4445 });
4446 }
4447 }
4448
4449 impl ::fidl_next::Constrained for DebugStartedPayload<'_> {
4450 type Constraint = ();
4451
4452 fn validate(
4453 _: ::fidl_next::Slot<'_, Self>,
4454 _: Self::Constraint,
4455 ) -> Result<(), ::fidl_next::ValidationError> {
4456 Ok(())
4457 }
4458 }
4459
4460 unsafe impl ::fidl_next::Wire for DebugStartedPayload<'static> {
4461 type Narrowed<'de> = DebugStartedPayload<'de>;
4462
4463 #[inline]
4464 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4465 ::fidl_next::munge!(let Self { table } = out);
4466 ::fidl_next::wire::Table::zero_padding(table);
4467 }
4468 }
4469
4470 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugStartedPayload<'de>
4471 where
4472 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4473 ___D: ::fidl_next::fuchsia::HandleDecoder,
4474 {
4475 fn decode(
4476 slot: ::fidl_next::Slot<'_, Self>,
4477 decoder: &mut ___D,
4478 _: (),
4479 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4480 ::fidl_next::munge!(let Self { table } = slot);
4481
4482 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4483 match ordinal {
4484 0 => unsafe { ::core::hint::unreachable_unchecked() },
4485
4486 1 => {
4487 ::fidl_next::wire::Envelope::decode_as::<
4488 ___D,
4489 ::fidl_next::ClientEnd<
4490 ::fidl_next_fuchsia_io::Directory,
4491 ::fidl_next::wire::fuchsia::Channel,
4492 >,
4493 >(slot.as_mut(), decoder, ())?;
4494
4495 Ok(())
4496 }
4497
4498 2 => {
4499 ::fidl_next::wire::Envelope::decode_as::<
4500 ___D,
4501 ::fidl_next::wire::fuchsia::EventPair,
4502 >(slot.as_mut(), decoder, ())?;
4503
4504 Ok(())
4505 }
4506
4507 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4508 }
4509 })
4510 }
4511 }
4512
4513 impl<'de> DebugStartedPayload<'de> {
4514 pub fn runtime_dir(
4515 &self,
4516 ) -> ::core::option::Option<
4517 &::fidl_next::ClientEnd<
4518 ::fidl_next_fuchsia_io::Directory,
4519 ::fidl_next::wire::fuchsia::Channel,
4520 >,
4521 > {
4522 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4523 }
4524
4525 pub fn take_runtime_dir(
4526 &mut self,
4527 ) -> ::core::option::Option<
4528 ::fidl_next::ClientEnd<
4529 ::fidl_next_fuchsia_io::Directory,
4530 ::fidl_next::wire::fuchsia::Channel,
4531 >,
4532 > {
4533 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4534 }
4535
4536 pub fn break_on_start(
4537 &self,
4538 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4539 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4540 }
4541
4542 pub fn take_break_on_start(
4543 &mut self,
4544 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
4545 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4546 }
4547 }
4548
4549 impl<'de> ::core::fmt::Debug for DebugStartedPayload<'de> {
4550 fn fmt(
4551 &self,
4552 f: &mut ::core::fmt::Formatter<'_>,
4553 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4554 f.debug_struct("DebugStartedPayload")
4555 .field("runtime_dir", &self.runtime_dir())
4556 .field("break_on_start", &self.break_on_start())
4557 .finish()
4558 }
4559 }
4560
4561 impl<'de> ::fidl_next::IntoNatural for DebugStartedPayload<'de> {
4562 type Natural = crate::natural::DebugStartedPayload;
4563 }
4564
4565 #[repr(transparent)]
4567 pub struct EventPayload<'de> {
4568 pub(crate) raw: ::fidl_next::wire::Union,
4569 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4570 }
4571
4572 impl<'de> Drop for EventPayload<'de> {
4573 fn drop(&mut self) {
4574 match self.raw.ordinal() {
4575 1 => {
4576 let _ = unsafe {
4577 self.raw
4578 .get()
4579 .read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4580 };
4581 }
4582
4583 2 => {
4584 let _ = unsafe {
4585 self.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4586 };
4587 }
4588
4589 4 => {
4590 let _ = unsafe {
4591 self.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4592 };
4593 }
4594
4595 5 => {
4596 let _ = unsafe {
4597 self.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4598 };
4599 }
4600
4601 6 => {
4602 let _ = unsafe {
4603 self.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4604 };
4605 }
4606
4607 7 => {
4608 let _ = unsafe {
4609 self.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4610 };
4611 }
4612
4613 8 => {
4614 let _ = unsafe {
4615 self.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4616 };
4617 }
4618
4619 9 => {
4620 let _ = unsafe {
4621 self.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4622 };
4623 }
4624
4625 10 => {
4626 let _ = unsafe {
4627 self.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4628 };
4629 }
4630
4631 _ => (),
4632 }
4633 }
4634 }
4635
4636 impl ::fidl_next::Constrained for EventPayload<'_> {
4637 type Constraint = ();
4638
4639 fn validate(
4640 _: ::fidl_next::Slot<'_, Self>,
4641 _: Self::Constraint,
4642 ) -> Result<(), ::fidl_next::ValidationError> {
4643 Ok(())
4644 }
4645 }
4646
4647 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
4648 type Narrowed<'de> = EventPayload<'de>;
4649
4650 #[inline]
4651 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4652 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4653 ::fidl_next::wire::Union::zero_padding(raw);
4654 }
4655 }
4656
4657 pub mod event_payload {
4658 pub enum Ref<'de> {
4659 CapabilityRequested(&'de crate::wire::CapabilityRequestedPayload<'de>),
4660
4661 Purged(&'de crate::wire::PurgedPayload<'de>),
4662
4663 Discovered(&'de crate::wire::DiscoveredPayload<'de>),
4664
4665 Destroyed(&'de crate::wire::DestroyedPayload<'de>),
4666
4667 Resolved(&'de crate::wire::ResolvedPayload<'de>),
4668
4669 Started(&'de crate::wire::StartedPayload<'de>),
4670
4671 Stopped(&'de crate::wire::StoppedPayload<'de>),
4672
4673 DebugStarted(&'de crate::wire::DebugStartedPayload<'de>),
4674
4675 Unresolved(&'de crate::wire::UnresolvedPayload<'de>),
4676
4677 UnknownOrdinal_(u64),
4678 }
4679
4680 pub enum Value<'de> {
4681 CapabilityRequested(crate::wire::CapabilityRequestedPayload<'de>),
4682
4683 Purged(crate::wire::PurgedPayload<'de>),
4684
4685 Discovered(crate::wire::DiscoveredPayload<'de>),
4686
4687 Destroyed(crate::wire::DestroyedPayload<'de>),
4688
4689 Resolved(crate::wire::ResolvedPayload<'de>),
4690
4691 Started(crate::wire::StartedPayload<'de>),
4692
4693 Stopped(crate::wire::StoppedPayload<'de>),
4694
4695 DebugStarted(crate::wire::DebugStartedPayload<'de>),
4696
4697 Unresolved(crate::wire::UnresolvedPayload<'de>),
4698
4699 UnknownOrdinal_(u64),
4700 }
4701 }
4702
4703 impl<'de> EventPayload<'de> {
4704 pub fn as_ref(&self) -> crate::wire::event_payload::Ref<'_> {
4705 match self.raw.ordinal() {
4706 1 => crate::wire::event_payload::Ref::CapabilityRequested(unsafe {
4707 self.raw.get().deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4708 }),
4709
4710 2 => crate::wire::event_payload::Ref::Purged(unsafe {
4711 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>()
4712 }),
4713
4714 4 => crate::wire::event_payload::Ref::Discovered(unsafe {
4715 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>()
4716 }),
4717
4718 5 => crate::wire::event_payload::Ref::Destroyed(unsafe {
4719 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>()
4720 }),
4721
4722 6 => crate::wire::event_payload::Ref::Resolved(unsafe {
4723 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>()
4724 }),
4725
4726 7 => crate::wire::event_payload::Ref::Started(unsafe {
4727 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>()
4728 }),
4729
4730 8 => crate::wire::event_payload::Ref::Stopped(unsafe {
4731 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>()
4732 }),
4733
4734 9 => crate::wire::event_payload::Ref::DebugStarted(unsafe {
4735 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>()
4736 }),
4737
4738 10 => crate::wire::event_payload::Ref::Unresolved(unsafe {
4739 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>()
4740 }),
4741
4742 unknown => crate::wire::event_payload::Ref::UnknownOrdinal_(unknown),
4743 }
4744 }
4745
4746 pub fn into_inner(self) -> crate::wire::event_payload::Value<'de> {
4747 let this = ::core::mem::ManuallyDrop::new(self);
4748
4749 match this.raw.ordinal() {
4750 1 => crate::wire::event_payload::Value::CapabilityRequested(unsafe {
4751 this.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4752 }),
4753
4754 2 => crate::wire::event_payload::Value::Purged(unsafe {
4755 this.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4756 }),
4757
4758 4 => crate::wire::event_payload::Value::Discovered(unsafe {
4759 this.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4760 }),
4761
4762 5 => crate::wire::event_payload::Value::Destroyed(unsafe {
4763 this.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4764 }),
4765
4766 6 => crate::wire::event_payload::Value::Resolved(unsafe {
4767 this.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4768 }),
4769
4770 7 => crate::wire::event_payload::Value::Started(unsafe {
4771 this.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4772 }),
4773
4774 8 => crate::wire::event_payload::Value::Stopped(unsafe {
4775 this.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4776 }),
4777
4778 9 => crate::wire::event_payload::Value::DebugStarted(unsafe {
4779 this.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4780 }),
4781
4782 10 => crate::wire::event_payload::Value::Unresolved(unsafe {
4783 this.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4784 }),
4785
4786 unknown => crate::wire::event_payload::Value::UnknownOrdinal_(unknown),
4787 }
4788 }
4789 }
4790
4791 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
4792 where
4793 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4794 ___D: ::fidl_next::Decoder<'de>,
4795 ___D: ::fidl_next::fuchsia::HandleDecoder,
4796 {
4797 fn decode(
4798 mut slot: ::fidl_next::Slot<'_, Self>,
4799 decoder: &mut ___D,
4800 _: (),
4801 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4802 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4803 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4804 1 => ::fidl_next::wire::Union::decode_as::<
4805 ___D,
4806 crate::wire::CapabilityRequestedPayload<'de>,
4807 >(raw, decoder, ())?,
4808
4809 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
4810 raw,
4811 decoder,
4812 (),
4813 )?,
4814
4815 4 => ::fidl_next::wire::Union::decode_as::<
4816 ___D,
4817 crate::wire::DiscoveredPayload<'de>,
4818 >(raw, decoder, ())?,
4819
4820 5 => {
4821 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
4822 raw,
4823 decoder,
4824 (),
4825 )?
4826 }
4827
4828 6 => {
4829 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
4830 raw,
4831 decoder,
4832 (),
4833 )?
4834 }
4835
4836 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
4837 raw,
4838 decoder,
4839 (),
4840 )?,
4841
4842 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
4843 raw,
4844 decoder,
4845 (),
4846 )?,
4847
4848 9 => ::fidl_next::wire::Union::decode_as::<
4849 ___D,
4850 crate::wire::DebugStartedPayload<'de>,
4851 >(raw, decoder, ())?,
4852
4853 10 => ::fidl_next::wire::Union::decode_as::<
4854 ___D,
4855 crate::wire::UnresolvedPayload<'de>,
4856 >(raw, decoder, ())?,
4857
4858 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4859 }
4860
4861 Ok(())
4862 }
4863 }
4864
4865 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
4866 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4867 match self.raw.ordinal() {
4868 1 => unsafe {
4869 self.raw
4870 .get()
4871 .deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4872 .fmt(f)
4873 },
4874 2 => unsafe {
4875 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>().fmt(f)
4876 },
4877 4 => unsafe {
4878 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>().fmt(f)
4879 },
4880 5 => unsafe {
4881 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>().fmt(f)
4882 },
4883 6 => unsafe {
4884 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>().fmt(f)
4885 },
4886 7 => unsafe {
4887 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>().fmt(f)
4888 },
4889 8 => unsafe {
4890 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>().fmt(f)
4891 },
4892 9 => unsafe {
4893 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>().fmt(f)
4894 },
4895 10 => unsafe {
4896 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>().fmt(f)
4897 },
4898 _ => unsafe { ::core::hint::unreachable_unchecked() },
4899 }
4900 }
4901 }
4902
4903 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
4904 type Natural = crate::natural::EventPayload;
4905 }
4906
4907 #[repr(C)]
4909 pub struct Event<'de> {
4910 pub(crate) table: ::fidl_next::wire::Table<'de>,
4911 }
4912
4913 impl<'de> Drop for Event<'de> {
4914 fn drop(&mut self) {
4915 let _ = self.table.get(1).map(|envelope| unsafe {
4916 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
4917 });
4918
4919 let _ = self.table.get(2).map(|envelope| unsafe {
4920 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
4921 });
4922 }
4923 }
4924
4925 impl ::fidl_next::Constrained for Event<'_> {
4926 type Constraint = ();
4927
4928 fn validate(
4929 _: ::fidl_next::Slot<'_, Self>,
4930 _: Self::Constraint,
4931 ) -> Result<(), ::fidl_next::ValidationError> {
4932 Ok(())
4933 }
4934 }
4935
4936 unsafe impl ::fidl_next::Wire for Event<'static> {
4937 type Narrowed<'de> = Event<'de>;
4938
4939 #[inline]
4940 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4941 ::fidl_next::munge!(let Self { table } = out);
4942 ::fidl_next::wire::Table::zero_padding(table);
4943 }
4944 }
4945
4946 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Event<'de>
4947 where
4948 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4949 ___D: ::fidl_next::fuchsia::HandleDecoder,
4950 {
4951 fn decode(
4952 slot: ::fidl_next::Slot<'_, Self>,
4953 decoder: &mut ___D,
4954 _: (),
4955 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4956 ::fidl_next::munge!(let Self { table } = slot);
4957
4958 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4959 match ordinal {
4960 0 => unsafe { ::core::hint::unreachable_unchecked() },
4961
4962 1 => {
4963 ::fidl_next::wire::Envelope::decode_as::<
4964 ___D,
4965 crate::wire::EventHeader<'de>,
4966 >(slot.as_mut(), decoder, ())?;
4967
4968 Ok(())
4969 }
4970
4971 2 => {
4972 ::fidl_next::wire::Envelope::decode_as::<
4973 ___D,
4974 crate::wire::EventPayload<'de>,
4975 >(slot.as_mut(), decoder, ())?;
4976
4977 Ok(())
4978 }
4979
4980 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4981 }
4982 })
4983 }
4984 }
4985
4986 impl<'de> Event<'de> {
4987 pub fn header(&self) -> ::core::option::Option<&crate::wire::EventHeader<'de>> {
4988 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4989 }
4990
4991 pub fn take_header(&mut self) -> ::core::option::Option<crate::wire::EventHeader<'de>> {
4992 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4993 }
4994
4995 pub fn payload(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
4996 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4997 }
4998
4999 pub fn take_payload(&mut self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
5000 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
5001 }
5002 }
5003
5004 impl<'de> ::core::fmt::Debug for Event<'de> {
5005 fn fmt(
5006 &self,
5007 f: &mut ::core::fmt::Formatter<'_>,
5008 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5009 f.debug_struct("Event")
5010 .field("header", &self.header())
5011 .field("payload", &self.payload())
5012 .finish()
5013 }
5014 }
5015
5016 impl<'de> ::fidl_next::IntoNatural for Event<'de> {
5017 type Natural = crate::natural::Event;
5018 }
5019
5020 #[derive(Debug)]
5022 #[repr(C)]
5023 pub struct EventStreamGetNextResponse<'de> {
5024 pub events: ::fidl_next::wire::Vector<'de, crate::wire::Event<'de>>,
5025 }
5026
5027 static_assertions::const_assert_eq!(std::mem::size_of::<EventStreamGetNextResponse<'_>>(), 16);
5028 static_assertions::const_assert_eq!(std::mem::align_of::<EventStreamGetNextResponse<'_>>(), 8);
5029
5030 static_assertions::const_assert_eq!(
5031 std::mem::offset_of!(EventStreamGetNextResponse<'_>, events),
5032 0
5033 );
5034
5035 impl ::fidl_next::Constrained for EventStreamGetNextResponse<'_> {
5036 type Constraint = ();
5037
5038 fn validate(
5039 _: ::fidl_next::Slot<'_, Self>,
5040 _: Self::Constraint,
5041 ) -> Result<(), ::fidl_next::ValidationError> {
5042 Ok(())
5043 }
5044 }
5045
5046 unsafe impl ::fidl_next::Wire for EventStreamGetNextResponse<'static> {
5047 type Narrowed<'de> = EventStreamGetNextResponse<'de>;
5048
5049 #[inline]
5050 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5051 ::fidl_next::munge! {
5052 let Self {
5053 events,
5054
5055 } = &mut *out_;
5056 }
5057
5058 ::fidl_next::Wire::zero_padding(events);
5059 }
5060 }
5061
5062 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStreamGetNextResponse<'de>
5063 where
5064 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5065 ___D: ::fidl_next::Decoder<'de>,
5066 ___D: ::fidl_next::fuchsia::HandleDecoder,
5067 {
5068 fn decode(
5069 slot_: ::fidl_next::Slot<'_, Self>,
5070 decoder_: &mut ___D,
5071 _: (),
5072 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5073 ::fidl_next::munge! {
5074 let Self {
5075 mut events,
5076
5077 } = slot_;
5078 }
5079
5080 let _field = events.as_mut();
5081 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5082 ::fidl_next::Decode::decode(events.as_mut(), decoder_, (4294967295, ()))?;
5083
5084 Ok(())
5085 }
5086 }
5087
5088 impl<'de> ::fidl_next::IntoNatural for EventStreamGetNextResponse<'de> {
5089 type Natural = crate::natural::EventStreamGetNextResponse;
5090 }
5091
5092 #[derive(Debug)]
5094 #[repr(C)]
5095 pub struct IntrospectorGetMonikerRequest {
5096 pub component_instance: ::fidl_next::wire::fuchsia::Event,
5097 }
5098
5099 static_assertions::const_assert_eq!(std::mem::size_of::<IntrospectorGetMonikerRequest>(), 4);
5100 static_assertions::const_assert_eq!(std::mem::align_of::<IntrospectorGetMonikerRequest>(), 4);
5101
5102 static_assertions::const_assert_eq!(
5103 std::mem::offset_of!(IntrospectorGetMonikerRequest, component_instance),
5104 0
5105 );
5106
5107 impl ::fidl_next::Constrained for IntrospectorGetMonikerRequest {
5108 type Constraint = ();
5109
5110 fn validate(
5111 _: ::fidl_next::Slot<'_, Self>,
5112 _: Self::Constraint,
5113 ) -> Result<(), ::fidl_next::ValidationError> {
5114 Ok(())
5115 }
5116 }
5117
5118 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerRequest {
5119 type Narrowed<'de> = IntrospectorGetMonikerRequest;
5120
5121 #[inline]
5122 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5123 ::fidl_next::munge! {
5124 let Self {
5125 component_instance,
5126
5127 } = &mut *out_;
5128 }
5129
5130 ::fidl_next::Wire::zero_padding(component_instance);
5131 }
5132 }
5133
5134 unsafe impl<___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerRequest
5135 where
5136 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5137 ___D: ::fidl_next::fuchsia::HandleDecoder,
5138 {
5139 fn decode(
5140 slot_: ::fidl_next::Slot<'_, Self>,
5141 decoder_: &mut ___D,
5142 _: (),
5143 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5144 ::fidl_next::munge! {
5145 let Self {
5146 mut component_instance,
5147
5148 } = slot_;
5149 }
5150
5151 let _field = component_instance.as_mut();
5152
5153 ::fidl_next::Decode::decode(component_instance.as_mut(), decoder_, ())?;
5154
5155 Ok(())
5156 }
5157 }
5158
5159 impl ::fidl_next::IntoNatural for IntrospectorGetMonikerRequest {
5160 type Natural = crate::natural::IntrospectorGetMonikerRequest;
5161 }
5162
5163 #[derive(Debug)]
5165 #[repr(C)]
5166 pub struct NamespaceInputEntry<'de> {
5167 pub path: ::fidl_next::wire::String<'de>,
5168
5169 pub dictionary: ::fidl_next::ClientEnd<
5170 ::fidl_next_fuchsia_component_sandbox::Dictionary,
5171 ::fidl_next::wire::fuchsia::Channel,
5172 >,
5173 }
5174
5175 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry<'_>>(), 24);
5176 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry<'_>>(), 8);
5177
5178 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry<'_>, path), 0);
5179
5180 static_assertions::const_assert_eq!(
5181 std::mem::offset_of!(NamespaceInputEntry<'_>, dictionary),
5182 16
5183 );
5184
5185 impl ::fidl_next::Constrained for NamespaceInputEntry<'_> {
5186 type Constraint = ();
5187
5188 fn validate(
5189 _: ::fidl_next::Slot<'_, Self>,
5190 _: Self::Constraint,
5191 ) -> Result<(), ::fidl_next::ValidationError> {
5192 Ok(())
5193 }
5194 }
5195
5196 unsafe impl ::fidl_next::Wire for NamespaceInputEntry<'static> {
5197 type Narrowed<'de> = NamespaceInputEntry<'de>;
5198
5199 #[inline]
5200 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5201 ::fidl_next::munge! {
5202 let Self {
5203 path,
5204 dictionary,
5205
5206 } = &mut *out_;
5207 }
5208
5209 ::fidl_next::Wire::zero_padding(path);
5210
5211 ::fidl_next::Wire::zero_padding(dictionary);
5212
5213 unsafe {
5214 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5215 }
5216 }
5217 }
5218
5219 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry<'de>
5220 where
5221 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5222 ___D: ::fidl_next::Decoder<'de>,
5223 ___D: ::fidl_next::fuchsia::HandleDecoder,
5224 {
5225 fn decode(
5226 slot_: ::fidl_next::Slot<'_, Self>,
5227 decoder_: &mut ___D,
5228 _: (),
5229 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5230 if slot_.as_bytes()[20..24] != [0u8; 4] {
5231 return Err(::fidl_next::DecodeError::InvalidPadding);
5232 }
5233
5234 ::fidl_next::munge! {
5235 let Self {
5236 mut path,
5237 mut dictionary,
5238
5239 } = slot_;
5240 }
5241
5242 let _field = path.as_mut();
5243 ::fidl_next::Constrained::validate(_field, 4095)?;
5244 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5245
5246 let path = unsafe { path.deref_unchecked() };
5247
5248 if path.len() > 4095 {
5249 return Err(::fidl_next::DecodeError::VectorTooLong {
5250 size: path.len() as u64,
5251 limit: 4095,
5252 });
5253 }
5254
5255 let _field = dictionary.as_mut();
5256
5257 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5258
5259 Ok(())
5260 }
5261 }
5262
5263 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry<'de> {
5264 type Natural = crate::natural::NamespaceInputEntry;
5265 }
5266
5267 #[derive(Debug)]
5269 #[repr(C)]
5270 pub struct NamespaceCreateRequest<'de> {
5271 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry<'de>>,
5272 }
5273
5274 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateRequest<'_>>(), 16);
5275 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateRequest<'_>>(), 8);
5276
5277 static_assertions::const_assert_eq!(
5278 std::mem::offset_of!(NamespaceCreateRequest<'_>, entries),
5279 0
5280 );
5281
5282 impl ::fidl_next::Constrained for NamespaceCreateRequest<'_> {
5283 type Constraint = ();
5284
5285 fn validate(
5286 _: ::fidl_next::Slot<'_, Self>,
5287 _: Self::Constraint,
5288 ) -> Result<(), ::fidl_next::ValidationError> {
5289 Ok(())
5290 }
5291 }
5292
5293 unsafe impl ::fidl_next::Wire for NamespaceCreateRequest<'static> {
5294 type Narrowed<'de> = NamespaceCreateRequest<'de>;
5295
5296 #[inline]
5297 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5298 ::fidl_next::munge! {
5299 let Self {
5300 entries,
5301
5302 } = &mut *out_;
5303 }
5304
5305 ::fidl_next::Wire::zero_padding(entries);
5306 }
5307 }
5308
5309 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateRequest<'de>
5310 where
5311 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5312 ___D: ::fidl_next::Decoder<'de>,
5313 ___D: ::fidl_next::fuchsia::HandleDecoder,
5314 {
5315 fn decode(
5316 slot_: ::fidl_next::Slot<'_, Self>,
5317 decoder_: &mut ___D,
5318 _: (),
5319 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5320 ::fidl_next::munge! {
5321 let Self {
5322 mut entries,
5323
5324 } = slot_;
5325 }
5326
5327 let _field = entries.as_mut();
5328 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5329 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5330
5331 Ok(())
5332 }
5333 }
5334
5335 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateRequest<'de> {
5336 type Natural = crate::natural::NamespaceCreateRequest;
5337 }
5338
5339 #[derive(Debug)]
5341 #[repr(C)]
5342 pub struct NamespaceInputEntry2<'de> {
5343 pub path: ::fidl_next::wire::String<'de>,
5344
5345 pub capability: ::fidl_next::wire::fuchsia::EventPair,
5346 }
5347
5348 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry2<'_>>(), 24);
5349 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry2<'_>>(), 8);
5350
5351 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry2<'_>, path), 0);
5352
5353 static_assertions::const_assert_eq!(
5354 std::mem::offset_of!(NamespaceInputEntry2<'_>, capability),
5355 16
5356 );
5357
5358 impl ::fidl_next::Constrained for NamespaceInputEntry2<'_> {
5359 type Constraint = ();
5360
5361 fn validate(
5362 _: ::fidl_next::Slot<'_, Self>,
5363 _: Self::Constraint,
5364 ) -> Result<(), ::fidl_next::ValidationError> {
5365 Ok(())
5366 }
5367 }
5368
5369 unsafe impl ::fidl_next::Wire for NamespaceInputEntry2<'static> {
5370 type Narrowed<'de> = NamespaceInputEntry2<'de>;
5371
5372 #[inline]
5373 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5374 ::fidl_next::munge! {
5375 let Self {
5376 path,
5377 capability,
5378
5379 } = &mut *out_;
5380 }
5381
5382 ::fidl_next::Wire::zero_padding(path);
5383
5384 ::fidl_next::Wire::zero_padding(capability);
5385
5386 unsafe {
5387 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5388 }
5389 }
5390 }
5391
5392 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry2<'de>
5393 where
5394 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5395 ___D: ::fidl_next::Decoder<'de>,
5396 ___D: ::fidl_next::fuchsia::HandleDecoder,
5397 {
5398 fn decode(
5399 slot_: ::fidl_next::Slot<'_, Self>,
5400 decoder_: &mut ___D,
5401 _: (),
5402 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5403 if slot_.as_bytes()[20..24] != [0u8; 4] {
5404 return Err(::fidl_next::DecodeError::InvalidPadding);
5405 }
5406
5407 ::fidl_next::munge! {
5408 let Self {
5409 mut path,
5410 mut capability,
5411
5412 } = slot_;
5413 }
5414
5415 let _field = path.as_mut();
5416 ::fidl_next::Constrained::validate(_field, 4095)?;
5417 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5418
5419 let path = unsafe { path.deref_unchecked() };
5420
5421 if path.len() > 4095 {
5422 return Err(::fidl_next::DecodeError::VectorTooLong {
5423 size: path.len() as u64,
5424 limit: 4095,
5425 });
5426 }
5427
5428 let _field = capability.as_mut();
5429
5430 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5431
5432 Ok(())
5433 }
5434 }
5435
5436 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry2<'de> {
5437 type Natural = crate::natural::NamespaceInputEntry2;
5438 }
5439
5440 #[derive(Debug)]
5442 #[repr(C)]
5443 pub struct NamespaceCreate2Request<'de> {
5444 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry2<'de>>,
5445 }
5446
5447 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Request<'_>>(), 16);
5448 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Request<'_>>(), 8);
5449
5450 static_assertions::const_assert_eq!(
5451 std::mem::offset_of!(NamespaceCreate2Request<'_>, entries),
5452 0
5453 );
5454
5455 impl ::fidl_next::Constrained for NamespaceCreate2Request<'_> {
5456 type Constraint = ();
5457
5458 fn validate(
5459 _: ::fidl_next::Slot<'_, Self>,
5460 _: Self::Constraint,
5461 ) -> Result<(), ::fidl_next::ValidationError> {
5462 Ok(())
5463 }
5464 }
5465
5466 unsafe impl ::fidl_next::Wire for NamespaceCreate2Request<'static> {
5467 type Narrowed<'de> = NamespaceCreate2Request<'de>;
5468
5469 #[inline]
5470 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5471 ::fidl_next::munge! {
5472 let Self {
5473 entries,
5474
5475 } = &mut *out_;
5476 }
5477
5478 ::fidl_next::Wire::zero_padding(entries);
5479 }
5480 }
5481
5482 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Request<'de>
5483 where
5484 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5485 ___D: ::fidl_next::Decoder<'de>,
5486 ___D: ::fidl_next::fuchsia::HandleDecoder,
5487 {
5488 fn decode(
5489 slot_: ::fidl_next::Slot<'_, Self>,
5490 decoder_: &mut ___D,
5491 _: (),
5492 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5493 ::fidl_next::munge! {
5494 let Self {
5495 mut entries,
5496
5497 } = slot_;
5498 }
5499
5500 let _field = entries.as_mut();
5501 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5502 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5503
5504 Ok(())
5505 }
5506 }
5507
5508 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Request<'de> {
5509 type Natural = crate::natural::NamespaceCreate2Request;
5510 }
5511
5512 #[derive(Debug)]
5514 #[repr(C)]
5515 pub struct NamespaceCreateResponse<'de> {
5516 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5517 }
5518
5519 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateResponse<'_>>(), 16);
5520 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateResponse<'_>>(), 8);
5521
5522 static_assertions::const_assert_eq!(
5523 std::mem::offset_of!(NamespaceCreateResponse<'_>, entries),
5524 0
5525 );
5526
5527 impl ::fidl_next::Constrained for NamespaceCreateResponse<'_> {
5528 type Constraint = ();
5529
5530 fn validate(
5531 _: ::fidl_next::Slot<'_, Self>,
5532 _: Self::Constraint,
5533 ) -> Result<(), ::fidl_next::ValidationError> {
5534 Ok(())
5535 }
5536 }
5537
5538 unsafe impl ::fidl_next::Wire for NamespaceCreateResponse<'static> {
5539 type Narrowed<'de> = NamespaceCreateResponse<'de>;
5540
5541 #[inline]
5542 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5543 ::fidl_next::munge! {
5544 let Self {
5545 entries,
5546
5547 } = &mut *out_;
5548 }
5549
5550 ::fidl_next::Wire::zero_padding(entries);
5551 }
5552 }
5553
5554 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateResponse<'de>
5555 where
5556 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5557 ___D: ::fidl_next::Decoder<'de>,
5558 ___D: ::fidl_next::fuchsia::HandleDecoder,
5559 {
5560 fn decode(
5561 slot_: ::fidl_next::Slot<'_, Self>,
5562 decoder_: &mut ___D,
5563 _: (),
5564 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5565 ::fidl_next::munge! {
5566 let Self {
5567 mut entries,
5568
5569 } = slot_;
5570 }
5571
5572 let _field = entries.as_mut();
5573 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5574 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5575
5576 Ok(())
5577 }
5578 }
5579
5580 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateResponse<'de> {
5581 type Natural = crate::natural::NamespaceCreateResponse;
5582 }
5583
5584 #[derive(Debug)]
5586 #[repr(C)]
5587 pub struct NamespaceCreate2Response<'de> {
5588 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5589 }
5590
5591 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Response<'_>>(), 16);
5592 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Response<'_>>(), 8);
5593
5594 static_assertions::const_assert_eq!(
5595 std::mem::offset_of!(NamespaceCreate2Response<'_>, entries),
5596 0
5597 );
5598
5599 impl ::fidl_next::Constrained for NamespaceCreate2Response<'_> {
5600 type Constraint = ();
5601
5602 fn validate(
5603 _: ::fidl_next::Slot<'_, Self>,
5604 _: Self::Constraint,
5605 ) -> Result<(), ::fidl_next::ValidationError> {
5606 Ok(())
5607 }
5608 }
5609
5610 unsafe impl ::fidl_next::Wire for NamespaceCreate2Response<'static> {
5611 type Narrowed<'de> = NamespaceCreate2Response<'de>;
5612
5613 #[inline]
5614 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5615 ::fidl_next::munge! {
5616 let Self {
5617 entries,
5618
5619 } = &mut *out_;
5620 }
5621
5622 ::fidl_next::Wire::zero_padding(entries);
5623 }
5624 }
5625
5626 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Response<'de>
5627 where
5628 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5629 ___D: ::fidl_next::Decoder<'de>,
5630 ___D: ::fidl_next::fuchsia::HandleDecoder,
5631 {
5632 fn decode(
5633 slot_: ::fidl_next::Slot<'_, Self>,
5634 decoder_: &mut ___D,
5635 _: (),
5636 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5637 ::fidl_next::munge! {
5638 let Self {
5639 mut entries,
5640
5641 } = slot_;
5642 }
5643
5644 let _field = entries.as_mut();
5645 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5646 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5647
5648 Ok(())
5649 }
5650 }
5651
5652 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Response<'de> {
5653 type Natural = crate::natural::NamespaceCreate2Response;
5654 }
5655
5656 #[derive(Debug)]
5658 #[repr(C)]
5659 pub struct RealmListChildrenRequest<'de> {
5660 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
5661
5662 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
5663 }
5664
5665 static_assertions::const_assert_eq!(std::mem::size_of::<RealmListChildrenRequest<'_>>(), 24);
5666 static_assertions::const_assert_eq!(std::mem::align_of::<RealmListChildrenRequest<'_>>(), 8);
5667
5668 static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(RealmListChildrenRequest<'_>, collection),
5670 0
5671 );
5672
5673 static_assertions::const_assert_eq!(
5674 std::mem::offset_of!(RealmListChildrenRequest<'_>, iter),
5675 16
5676 );
5677
5678 impl ::fidl_next::Constrained for RealmListChildrenRequest<'_> {
5679 type Constraint = ();
5680
5681 fn validate(
5682 _: ::fidl_next::Slot<'_, Self>,
5683 _: Self::Constraint,
5684 ) -> Result<(), ::fidl_next::ValidationError> {
5685 Ok(())
5686 }
5687 }
5688
5689 unsafe impl ::fidl_next::Wire for RealmListChildrenRequest<'static> {
5690 type Narrowed<'de> = RealmListChildrenRequest<'de>;
5691
5692 #[inline]
5693 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5694 ::fidl_next::munge! {
5695 let Self {
5696 collection,
5697 iter,
5698
5699 } = &mut *out_;
5700 }
5701
5702 ::fidl_next::Wire::zero_padding(collection);
5703
5704 ::fidl_next::Wire::zero_padding(iter);
5705
5706 unsafe {
5707 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5708 }
5709 }
5710 }
5711
5712 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmListChildrenRequest<'de>
5713 where
5714 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5715 ___D: ::fidl_next::Decoder<'de>,
5716 ___D: ::fidl_next::fuchsia::HandleDecoder,
5717 {
5718 fn decode(
5719 slot_: ::fidl_next::Slot<'_, Self>,
5720 decoder_: &mut ___D,
5721 _: (),
5722 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5723 if slot_.as_bytes()[20..24] != [0u8; 4] {
5724 return Err(::fidl_next::DecodeError::InvalidPadding);
5725 }
5726
5727 ::fidl_next::munge! {
5728 let Self {
5729 mut collection,
5730 mut iter,
5731
5732 } = slot_;
5733 }
5734
5735 let _field = collection.as_mut();
5736
5737 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
5738
5739 let _field = iter.as_mut();
5740
5741 ::fidl_next::Decode::decode(iter.as_mut(), decoder_, ())?;
5742
5743 Ok(())
5744 }
5745 }
5746
5747 impl<'de> ::fidl_next::IntoNatural for RealmListChildrenRequest<'de> {
5748 type Natural = crate::natural::RealmListChildrenRequest;
5749 }
5750
5751 #[derive(Debug)]
5753 #[repr(C)]
5754 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5755 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5756 }
5757
5758 static_assertions::const_assert_eq!(
5759 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5760 32
5761 );
5762 static_assertions::const_assert_eq!(
5763 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5764 8
5765 );
5766
5767 static_assertions::const_assert_eq!(
5768 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedRequest<'_>, child),
5769 0
5770 );
5771
5772 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedRequest<'_> {
5773 type Constraint = ();
5774
5775 fn validate(
5776 _: ::fidl_next::Slot<'_, Self>,
5777 _: Self::Constraint,
5778 ) -> Result<(), ::fidl_next::ValidationError> {
5779 Ok(())
5780 }
5781 }
5782
5783 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedRequest<'static> {
5784 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedRequest<'de>;
5785
5786 #[inline]
5787 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5788 ::fidl_next::munge! {
5789 let Self {
5790 child,
5791
5792 } = &mut *out_;
5793 }
5794
5795 ::fidl_next::Wire::zero_padding(child);
5796 }
5797 }
5798
5799 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5800 for RealmGetChildOutputDictionaryDeprecatedRequest<'de>
5801 where
5802 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5803 ___D: ::fidl_next::Decoder<'de>,
5804 ___D: ::fidl_next::fuchsia::HandleDecoder,
5805 {
5806 fn decode(
5807 slot_: ::fidl_next::Slot<'_, Self>,
5808 decoder_: &mut ___D,
5809 _: (),
5810 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5811 ::fidl_next::munge! {
5812 let Self {
5813 mut child,
5814
5815 } = slot_;
5816 }
5817
5818 let _field = child.as_mut();
5819
5820 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5821
5822 Ok(())
5823 }
5824 }
5825
5826 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5827 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
5828 }
5829
5830 #[derive(Debug)]
5832 #[repr(C)]
5833 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
5834 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
5835 }
5836
5837 static_assertions::const_assert_eq!(
5838 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5839 4
5840 );
5841 static_assertions::const_assert_eq!(
5842 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5843 4
5844 );
5845
5846 static_assertions::const_assert_eq!(
5847 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedResponse, dictionary),
5848 0
5849 );
5850
5851 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedResponse {
5852 type Constraint = ();
5853
5854 fn validate(
5855 _: ::fidl_next::Slot<'_, Self>,
5856 _: Self::Constraint,
5857 ) -> Result<(), ::fidl_next::ValidationError> {
5858 Ok(())
5859 }
5860 }
5861
5862 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedResponse {
5863 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedResponse;
5864
5865 #[inline]
5866 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5867 ::fidl_next::munge! {
5868 let Self {
5869 dictionary,
5870
5871 } = &mut *out_;
5872 }
5873
5874 ::fidl_next::Wire::zero_padding(dictionary);
5875 }
5876 }
5877
5878 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryDeprecatedResponse
5879 where
5880 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5881 ___D: ::fidl_next::fuchsia::HandleDecoder,
5882 {
5883 fn decode(
5884 slot_: ::fidl_next::Slot<'_, Self>,
5885 decoder_: &mut ___D,
5886 _: (),
5887 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5888 ::fidl_next::munge! {
5889 let Self {
5890 mut dictionary,
5891
5892 } = slot_;
5893 }
5894
5895 let _field = dictionary.as_mut();
5896
5897 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5898
5899 Ok(())
5900 }
5901 }
5902
5903 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedResponse {
5904 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
5905 }
5906
5907 #[derive(Debug)]
5909 #[repr(C)]
5910 pub struct RealmGetChildOutputDictionaryRequest<'de> {
5911 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5912 }
5913
5914 static_assertions::const_assert_eq!(
5915 std::mem::size_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5916 32
5917 );
5918 static_assertions::const_assert_eq!(
5919 std::mem::align_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5920 8
5921 );
5922
5923 static_assertions::const_assert_eq!(
5924 std::mem::offset_of!(RealmGetChildOutputDictionaryRequest<'_>, child),
5925 0
5926 );
5927
5928 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryRequest<'_> {
5929 type Constraint = ();
5930
5931 fn validate(
5932 _: ::fidl_next::Slot<'_, Self>,
5933 _: Self::Constraint,
5934 ) -> Result<(), ::fidl_next::ValidationError> {
5935 Ok(())
5936 }
5937 }
5938
5939 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryRequest<'static> {
5940 type Narrowed<'de> = RealmGetChildOutputDictionaryRequest<'de>;
5941
5942 #[inline]
5943 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5944 ::fidl_next::munge! {
5945 let Self {
5946 child,
5947
5948 } = &mut *out_;
5949 }
5950
5951 ::fidl_next::Wire::zero_padding(child);
5952 }
5953 }
5954
5955 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryRequest<'de>
5956 where
5957 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5958 ___D: ::fidl_next::Decoder<'de>,
5959 ___D: ::fidl_next::fuchsia::HandleDecoder,
5960 {
5961 fn decode(
5962 slot_: ::fidl_next::Slot<'_, Self>,
5963 decoder_: &mut ___D,
5964 _: (),
5965 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5966 ::fidl_next::munge! {
5967 let Self {
5968 mut child,
5969
5970 } = slot_;
5971 }
5972
5973 let _field = child.as_mut();
5974
5975 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5976
5977 Ok(())
5978 }
5979 }
5980
5981 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryRequest<'de> {
5982 type Natural = crate::natural::RealmGetChildOutputDictionaryRequest;
5983 }
5984
5985 #[derive(Debug)]
5987 #[repr(C)]
5988 pub struct RealmGetChildOutputDictionaryResponse {
5989 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
5990 }
5991
5992 static_assertions::const_assert_eq!(
5993 std::mem::size_of::<RealmGetChildOutputDictionaryResponse>(),
5994 4
5995 );
5996 static_assertions::const_assert_eq!(
5997 std::mem::align_of::<RealmGetChildOutputDictionaryResponse>(),
5998 4
5999 );
6000
6001 static_assertions::const_assert_eq!(
6002 std::mem::offset_of!(RealmGetChildOutputDictionaryResponse, dictionary),
6003 0
6004 );
6005
6006 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryResponse {
6007 type Constraint = ();
6008
6009 fn validate(
6010 _: ::fidl_next::Slot<'_, Self>,
6011 _: Self::Constraint,
6012 ) -> Result<(), ::fidl_next::ValidationError> {
6013 Ok(())
6014 }
6015 }
6016
6017 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryResponse {
6018 type Narrowed<'de> = RealmGetChildOutputDictionaryResponse;
6019
6020 #[inline]
6021 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6022 ::fidl_next::munge! {
6023 let Self {
6024 dictionary,
6025
6026 } = &mut *out_;
6027 }
6028
6029 ::fidl_next::Wire::zero_padding(dictionary);
6030 }
6031 }
6032
6033 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryResponse
6034 where
6035 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6036 ___D: ::fidl_next::fuchsia::HandleDecoder,
6037 {
6038 fn decode(
6039 slot_: ::fidl_next::Slot<'_, Self>,
6040 decoder_: &mut ___D,
6041 _: (),
6042 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6043 ::fidl_next::munge! {
6044 let Self {
6045 mut dictionary,
6046
6047 } = slot_;
6048 }
6049
6050 let _field = dictionary.as_mut();
6051
6052 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
6053
6054 Ok(())
6055 }
6056 }
6057
6058 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryResponse {
6059 type Natural = crate::natural::RealmGetChildOutputDictionaryResponse;
6060 }
6061
6062 #[derive(Debug)]
6064 #[repr(C)]
6065 pub struct RealmOpenControllerRequest<'de> {
6066 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
6067
6068 pub controller:
6069 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
6070 }
6071
6072 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenControllerRequest<'_>>(), 40);
6073 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenControllerRequest<'_>>(), 8);
6074
6075 static_assertions::const_assert_eq!(
6076 std::mem::offset_of!(RealmOpenControllerRequest<'_>, child),
6077 0
6078 );
6079
6080 static_assertions::const_assert_eq!(
6081 std::mem::offset_of!(RealmOpenControllerRequest<'_>, controller),
6082 32
6083 );
6084
6085 impl ::fidl_next::Constrained for RealmOpenControllerRequest<'_> {
6086 type Constraint = ();
6087
6088 fn validate(
6089 _: ::fidl_next::Slot<'_, Self>,
6090 _: Self::Constraint,
6091 ) -> Result<(), ::fidl_next::ValidationError> {
6092 Ok(())
6093 }
6094 }
6095
6096 unsafe impl ::fidl_next::Wire for RealmOpenControllerRequest<'static> {
6097 type Narrowed<'de> = RealmOpenControllerRequest<'de>;
6098
6099 #[inline]
6100 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6101 ::fidl_next::munge! {
6102 let Self {
6103 child,
6104 controller,
6105
6106 } = &mut *out_;
6107 }
6108
6109 ::fidl_next::Wire::zero_padding(child);
6110
6111 ::fidl_next::Wire::zero_padding(controller);
6112
6113 unsafe {
6114 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6115 }
6116 }
6117 }
6118
6119 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenControllerRequest<'de>
6120 where
6121 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6122 ___D: ::fidl_next::Decoder<'de>,
6123 ___D: ::fidl_next::fuchsia::HandleDecoder,
6124 {
6125 fn decode(
6126 slot_: ::fidl_next::Slot<'_, Self>,
6127 decoder_: &mut ___D,
6128 _: (),
6129 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6130 if slot_.as_bytes()[36..40] != [0u8; 4] {
6131 return Err(::fidl_next::DecodeError::InvalidPadding);
6132 }
6133
6134 ::fidl_next::munge! {
6135 let Self {
6136 mut child,
6137 mut controller,
6138
6139 } = slot_;
6140 }
6141
6142 let _field = child.as_mut();
6143
6144 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6145
6146 let _field = controller.as_mut();
6147
6148 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
6149
6150 Ok(())
6151 }
6152 }
6153
6154 impl<'de> ::fidl_next::IntoNatural for RealmOpenControllerRequest<'de> {
6155 type Natural = crate::natural::RealmOpenControllerRequest;
6156 }
6157
6158 #[derive(Debug)]
6160 #[repr(C)]
6161 pub struct RealmOpenExposedDirRequest<'de> {
6162 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
6163
6164 pub exposed_dir: ::fidl_next::ServerEnd<
6165 ::fidl_next_fuchsia_io::Directory,
6166 ::fidl_next::wire::fuchsia::Channel,
6167 >,
6168 }
6169
6170 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenExposedDirRequest<'_>>(), 40);
6171 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenExposedDirRequest<'_>>(), 8);
6172
6173 static_assertions::const_assert_eq!(
6174 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, child),
6175 0
6176 );
6177
6178 static_assertions::const_assert_eq!(
6179 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, exposed_dir),
6180 32
6181 );
6182
6183 impl ::fidl_next::Constrained for RealmOpenExposedDirRequest<'_> {
6184 type Constraint = ();
6185
6186 fn validate(
6187 _: ::fidl_next::Slot<'_, Self>,
6188 _: Self::Constraint,
6189 ) -> Result<(), ::fidl_next::ValidationError> {
6190 Ok(())
6191 }
6192 }
6193
6194 unsafe impl ::fidl_next::Wire for RealmOpenExposedDirRequest<'static> {
6195 type Narrowed<'de> = RealmOpenExposedDirRequest<'de>;
6196
6197 #[inline]
6198 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6199 ::fidl_next::munge! {
6200 let Self {
6201 child,
6202 exposed_dir,
6203
6204 } = &mut *out_;
6205 }
6206
6207 ::fidl_next::Wire::zero_padding(child);
6208
6209 ::fidl_next::Wire::zero_padding(exposed_dir);
6210
6211 unsafe {
6212 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6213 }
6214 }
6215 }
6216
6217 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenExposedDirRequest<'de>
6218 where
6219 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6220 ___D: ::fidl_next::Decoder<'de>,
6221 ___D: ::fidl_next::fuchsia::HandleDecoder,
6222 {
6223 fn decode(
6224 slot_: ::fidl_next::Slot<'_, Self>,
6225 decoder_: &mut ___D,
6226 _: (),
6227 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6228 if slot_.as_bytes()[36..40] != [0u8; 4] {
6229 return Err(::fidl_next::DecodeError::InvalidPadding);
6230 }
6231
6232 ::fidl_next::munge! {
6233 let Self {
6234 mut child,
6235 mut exposed_dir,
6236
6237 } = slot_;
6238 }
6239
6240 let _field = child.as_mut();
6241
6242 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6243
6244 let _field = exposed_dir.as_mut();
6245
6246 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
6247
6248 Ok(())
6249 }
6250 }
6251
6252 impl<'de> ::fidl_next::IntoNatural for RealmOpenExposedDirRequest<'de> {
6253 type Natural = crate::natural::RealmOpenExposedDirRequest;
6254 }
6255
6256 #[derive(Debug)]
6258 #[repr(C)]
6259 pub struct RealmCreateChildRequest<'de> {
6260 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
6261
6262 pub decl: ::fidl_next_fuchsia_component_decl::wire::Child<'de>,
6263
6264 pub args: crate::wire::CreateChildArgs<'de>,
6265 }
6266
6267 static_assertions::const_assert_eq!(std::mem::size_of::<RealmCreateChildRequest<'_>>(), 48);
6268 static_assertions::const_assert_eq!(std::mem::align_of::<RealmCreateChildRequest<'_>>(), 8);
6269
6270 static_assertions::const_assert_eq!(
6271 std::mem::offset_of!(RealmCreateChildRequest<'_>, collection),
6272 0
6273 );
6274
6275 static_assertions::const_assert_eq!(
6276 std::mem::offset_of!(RealmCreateChildRequest<'_>, decl),
6277 16
6278 );
6279
6280 static_assertions::const_assert_eq!(
6281 std::mem::offset_of!(RealmCreateChildRequest<'_>, args),
6282 32
6283 );
6284
6285 impl ::fidl_next::Constrained for RealmCreateChildRequest<'_> {
6286 type Constraint = ();
6287
6288 fn validate(
6289 _: ::fidl_next::Slot<'_, Self>,
6290 _: Self::Constraint,
6291 ) -> Result<(), ::fidl_next::ValidationError> {
6292 Ok(())
6293 }
6294 }
6295
6296 unsafe impl ::fidl_next::Wire for RealmCreateChildRequest<'static> {
6297 type Narrowed<'de> = RealmCreateChildRequest<'de>;
6298
6299 #[inline]
6300 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6301 ::fidl_next::munge! {
6302 let Self {
6303 collection,
6304 decl,
6305 args,
6306
6307 } = &mut *out_;
6308 }
6309
6310 ::fidl_next::Wire::zero_padding(collection);
6311
6312 ::fidl_next::Wire::zero_padding(decl);
6313
6314 ::fidl_next::Wire::zero_padding(args);
6315 }
6316 }
6317
6318 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmCreateChildRequest<'de>
6319 where
6320 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6321 ___D: ::fidl_next::Decoder<'de>,
6322 ___D: ::fidl_next::fuchsia::HandleDecoder,
6323 {
6324 fn decode(
6325 slot_: ::fidl_next::Slot<'_, Self>,
6326 decoder_: &mut ___D,
6327 _: (),
6328 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6329 ::fidl_next::munge! {
6330 let Self {
6331 mut collection,
6332 mut decl,
6333 mut args,
6334
6335 } = slot_;
6336 }
6337
6338 let _field = collection.as_mut();
6339
6340 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
6341
6342 let _field = decl.as_mut();
6343
6344 ::fidl_next::Decode::decode(decl.as_mut(), decoder_, ())?;
6345
6346 let _field = args.as_mut();
6347
6348 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
6349
6350 Ok(())
6351 }
6352 }
6353
6354 impl<'de> ::fidl_next::IntoNatural for RealmCreateChildRequest<'de> {
6355 type Natural = crate::natural::RealmCreateChildRequest;
6356 }
6357
6358 #[derive(Debug)]
6360 #[repr(C)]
6361 pub struct RealmGetResolvedInfoResponse<'de> {
6362 pub resolved_info: ::fidl_next_fuchsia_component_resolution::wire::Component<'de>,
6363 }
6364
6365 static_assertions::const_assert_eq!(
6366 std::mem::size_of::<RealmGetResolvedInfoResponse<'_>>(),
6367 16
6368 );
6369 static_assertions::const_assert_eq!(
6370 std::mem::align_of::<RealmGetResolvedInfoResponse<'_>>(),
6371 8
6372 );
6373
6374 static_assertions::const_assert_eq!(
6375 std::mem::offset_of!(RealmGetResolvedInfoResponse<'_>, resolved_info),
6376 0
6377 );
6378
6379 impl ::fidl_next::Constrained for RealmGetResolvedInfoResponse<'_> {
6380 type Constraint = ();
6381
6382 fn validate(
6383 _: ::fidl_next::Slot<'_, Self>,
6384 _: Self::Constraint,
6385 ) -> Result<(), ::fidl_next::ValidationError> {
6386 Ok(())
6387 }
6388 }
6389
6390 unsafe impl ::fidl_next::Wire for RealmGetResolvedInfoResponse<'static> {
6391 type Narrowed<'de> = RealmGetResolvedInfoResponse<'de>;
6392
6393 #[inline]
6394 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6395 ::fidl_next::munge! {
6396 let Self {
6397 resolved_info,
6398
6399 } = &mut *out_;
6400 }
6401
6402 ::fidl_next::Wire::zero_padding(resolved_info);
6403 }
6404 }
6405
6406 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetResolvedInfoResponse<'de>
6407 where
6408 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6409 ___D: ::fidl_next::Decoder<'de>,
6410 ___D: ::fidl_next::fuchsia::HandleDecoder,
6411 {
6412 fn decode(
6413 slot_: ::fidl_next::Slot<'_, Self>,
6414 decoder_: &mut ___D,
6415 _: (),
6416 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6417 ::fidl_next::munge! {
6418 let Self {
6419 mut resolved_info,
6420
6421 } = slot_;
6422 }
6423
6424 let _field = resolved_info.as_mut();
6425
6426 ::fidl_next::Decode::decode(resolved_info.as_mut(), decoder_, ())?;
6427
6428 Ok(())
6429 }
6430 }
6431
6432 impl<'de> ::fidl_next::IntoNatural for RealmGetResolvedInfoResponse<'de> {
6433 type Natural = crate::natural::RealmGetResolvedInfoResponse;
6434 }
6435
6436 #[derive(Debug)]
6438 #[repr(C)]
6439 pub struct StorageAdminListStorageInRealmRequest<'de> {
6440 pub relative_moniker: ::fidl_next::wire::String<'de>,
6441
6442 pub iterator:
6443 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
6444 }
6445
6446 static_assertions::const_assert_eq!(
6447 std::mem::size_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6448 24
6449 );
6450 static_assertions::const_assert_eq!(
6451 std::mem::align_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6452 8
6453 );
6454
6455 static_assertions::const_assert_eq!(
6456 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, relative_moniker),
6457 0
6458 );
6459
6460 static_assertions::const_assert_eq!(
6461 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, iterator),
6462 16
6463 );
6464
6465 impl ::fidl_next::Constrained for StorageAdminListStorageInRealmRequest<'_> {
6466 type Constraint = ();
6467
6468 fn validate(
6469 _: ::fidl_next::Slot<'_, Self>,
6470 _: Self::Constraint,
6471 ) -> Result<(), ::fidl_next::ValidationError> {
6472 Ok(())
6473 }
6474 }
6475
6476 unsafe impl ::fidl_next::Wire for StorageAdminListStorageInRealmRequest<'static> {
6477 type Narrowed<'de> = StorageAdminListStorageInRealmRequest<'de>;
6478
6479 #[inline]
6480 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6481 ::fidl_next::munge! {
6482 let Self {
6483 relative_moniker,
6484 iterator,
6485
6486 } = &mut *out_;
6487 }
6488
6489 ::fidl_next::Wire::zero_padding(relative_moniker);
6490
6491 ::fidl_next::Wire::zero_padding(iterator);
6492
6493 unsafe {
6494 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6495 }
6496 }
6497 }
6498
6499 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminListStorageInRealmRequest<'de>
6500 where
6501 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6502 ___D: ::fidl_next::Decoder<'de>,
6503 ___D: ::fidl_next::fuchsia::HandleDecoder,
6504 {
6505 fn decode(
6506 slot_: ::fidl_next::Slot<'_, Self>,
6507 decoder_: &mut ___D,
6508 _: (),
6509 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6510 if slot_.as_bytes()[20..24] != [0u8; 4] {
6511 return Err(::fidl_next::DecodeError::InvalidPadding);
6512 }
6513
6514 ::fidl_next::munge! {
6515 let Self {
6516 mut relative_moniker,
6517 mut iterator,
6518
6519 } = slot_;
6520 }
6521
6522 let _field = relative_moniker.as_mut();
6523 ::fidl_next::Constrained::validate(_field, 4096)?;
6524 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6525
6526 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6527
6528 if relative_moniker.len() > 4096 {
6529 return Err(::fidl_next::DecodeError::VectorTooLong {
6530 size: relative_moniker.len() as u64,
6531 limit: 4096,
6532 });
6533 }
6534
6535 let _field = iterator.as_mut();
6536
6537 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
6538
6539 Ok(())
6540 }
6541 }
6542
6543 impl<'de> ::fidl_next::IntoNatural for StorageAdminListStorageInRealmRequest<'de> {
6544 type Natural = crate::natural::StorageAdminListStorageInRealmRequest;
6545 }
6546
6547 #[derive(Debug)]
6549 #[repr(C)]
6550 pub struct StorageAdminOpenStorageRequest<'de> {
6551 pub relative_moniker: ::fidl_next::wire::String<'de>,
6552
6553 pub object: ::fidl_next::ServerEnd<
6554 ::fidl_next_fuchsia_io::Node,
6555 ::fidl_next::wire::fuchsia::Channel,
6556 >,
6557 }
6558
6559 static_assertions::const_assert_eq!(
6560 std::mem::size_of::<StorageAdminOpenStorageRequest<'_>>(),
6561 24
6562 );
6563 static_assertions::const_assert_eq!(
6564 std::mem::align_of::<StorageAdminOpenStorageRequest<'_>>(),
6565 8
6566 );
6567
6568 static_assertions::const_assert_eq!(
6569 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, relative_moniker),
6570 0
6571 );
6572
6573 static_assertions::const_assert_eq!(
6574 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, object),
6575 16
6576 );
6577
6578 impl ::fidl_next::Constrained for StorageAdminOpenStorageRequest<'_> {
6579 type Constraint = ();
6580
6581 fn validate(
6582 _: ::fidl_next::Slot<'_, Self>,
6583 _: Self::Constraint,
6584 ) -> Result<(), ::fidl_next::ValidationError> {
6585 Ok(())
6586 }
6587 }
6588
6589 unsafe impl ::fidl_next::Wire for StorageAdminOpenStorageRequest<'static> {
6590 type Narrowed<'de> = StorageAdminOpenStorageRequest<'de>;
6591
6592 #[inline]
6593 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6594 ::fidl_next::munge! {
6595 let Self {
6596 relative_moniker,
6597 object,
6598
6599 } = &mut *out_;
6600 }
6601
6602 ::fidl_next::Wire::zero_padding(relative_moniker);
6603
6604 ::fidl_next::Wire::zero_padding(object);
6605
6606 unsafe {
6607 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6608 }
6609 }
6610 }
6611
6612 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminOpenStorageRequest<'de>
6613 where
6614 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6615 ___D: ::fidl_next::Decoder<'de>,
6616 ___D: ::fidl_next::fuchsia::HandleDecoder,
6617 {
6618 fn decode(
6619 slot_: ::fidl_next::Slot<'_, Self>,
6620 decoder_: &mut ___D,
6621 _: (),
6622 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6623 if slot_.as_bytes()[20..24] != [0u8; 4] {
6624 return Err(::fidl_next::DecodeError::InvalidPadding);
6625 }
6626
6627 ::fidl_next::munge! {
6628 let Self {
6629 mut relative_moniker,
6630 mut object,
6631
6632 } = slot_;
6633 }
6634
6635 let _field = relative_moniker.as_mut();
6636 ::fidl_next::Constrained::validate(_field, 4096)?;
6637 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6638
6639 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6640
6641 if relative_moniker.len() > 4096 {
6642 return Err(::fidl_next::DecodeError::VectorTooLong {
6643 size: relative_moniker.len() as u64,
6644 limit: 4096,
6645 });
6646 }
6647
6648 let _field = object.as_mut();
6649
6650 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6651
6652 Ok(())
6653 }
6654 }
6655
6656 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenStorageRequest<'de> {
6657 type Natural = crate::natural::StorageAdminOpenStorageRequest;
6658 }
6659
6660 #[derive(Debug)]
6662 #[repr(C)]
6663 pub struct StorageAdminOpenComponentStorageByIdRequest<'de> {
6664 pub id: ::fidl_next::wire::String<'de>,
6665
6666 pub object: ::fidl_next::ServerEnd<
6667 ::fidl_next_fuchsia_io::Node,
6668 ::fidl_next::wire::fuchsia::Channel,
6669 >,
6670 }
6671
6672 static_assertions::const_assert_eq!(
6673 std::mem::size_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6674 24
6675 );
6676 static_assertions::const_assert_eq!(
6677 std::mem::align_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6678 8
6679 );
6680
6681 static_assertions::const_assert_eq!(
6682 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, id),
6683 0
6684 );
6685
6686 static_assertions::const_assert_eq!(
6687 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, object),
6688 16
6689 );
6690
6691 impl ::fidl_next::Constrained for StorageAdminOpenComponentStorageByIdRequest<'_> {
6692 type Constraint = ();
6693
6694 fn validate(
6695 _: ::fidl_next::Slot<'_, Self>,
6696 _: Self::Constraint,
6697 ) -> Result<(), ::fidl_next::ValidationError> {
6698 Ok(())
6699 }
6700 }
6701
6702 unsafe impl ::fidl_next::Wire for StorageAdminOpenComponentStorageByIdRequest<'static> {
6703 type Narrowed<'de> = StorageAdminOpenComponentStorageByIdRequest<'de>;
6704
6705 #[inline]
6706 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6707 ::fidl_next::munge! {
6708 let Self {
6709 id,
6710 object,
6711
6712 } = &mut *out_;
6713 }
6714
6715 ::fidl_next::Wire::zero_padding(id);
6716
6717 ::fidl_next::Wire::zero_padding(object);
6718
6719 unsafe {
6720 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6721 }
6722 }
6723 }
6724
6725 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6726 for StorageAdminOpenComponentStorageByIdRequest<'de>
6727 where
6728 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6729 ___D: ::fidl_next::Decoder<'de>,
6730 ___D: ::fidl_next::fuchsia::HandleDecoder,
6731 {
6732 fn decode(
6733 slot_: ::fidl_next::Slot<'_, Self>,
6734 decoder_: &mut ___D,
6735 _: (),
6736 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6737 if slot_.as_bytes()[20..24] != [0u8; 4] {
6738 return Err(::fidl_next::DecodeError::InvalidPadding);
6739 }
6740
6741 ::fidl_next::munge! {
6742 let Self {
6743 mut id,
6744 mut object,
6745
6746 } = slot_;
6747 }
6748
6749 let _field = id.as_mut();
6750 ::fidl_next::Constrained::validate(_field, 64)?;
6751 ::fidl_next::Decode::decode(id.as_mut(), decoder_, 64)?;
6752
6753 let id = unsafe { id.deref_unchecked() };
6754
6755 if id.len() > 64 {
6756 return Err(::fidl_next::DecodeError::VectorTooLong {
6757 size: id.len() as u64,
6758 limit: 64,
6759 });
6760 }
6761
6762 let _field = object.as_mut();
6763
6764 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6765
6766 Ok(())
6767 }
6768 }
6769
6770 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenComponentStorageByIdRequest<'de> {
6771 type Natural = crate::natural::StorageAdminOpenComponentStorageByIdRequest;
6772 }
6773}
6774
6775pub mod wire_optional {
6776
6777 pub use fidl_next_common_fuchsia_component::wire_optional::*;
6778
6779 #[repr(transparent)]
6780 pub struct EventPayload<'de> {
6781 pub(crate) raw: ::fidl_next::wire::Union,
6782 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6783 }
6784
6785 impl ::fidl_next::Constrained for EventPayload<'_> {
6786 type Constraint = ();
6787
6788 fn validate(
6789 _: ::fidl_next::Slot<'_, Self>,
6790 _: Self::Constraint,
6791 ) -> Result<(), ::fidl_next::ValidationError> {
6792 Ok(())
6793 }
6794 }
6795
6796 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
6797 type Narrowed<'de> = EventPayload<'de>;
6798
6799 #[inline]
6800 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6801 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6802 ::fidl_next::wire::Union::zero_padding(raw);
6803 }
6804 }
6805
6806 impl<'de> EventPayload<'de> {
6807 pub fn is_some(&self) -> bool {
6808 self.raw.is_some()
6809 }
6810
6811 pub fn is_none(&self) -> bool {
6812 self.raw.is_none()
6813 }
6814
6815 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
6816 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6817 }
6818
6819 pub fn into_option(self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
6820 if self.is_some() {
6821 Some(crate::wire::EventPayload {
6822 raw: self.raw,
6823 _phantom: ::core::marker::PhantomData,
6824 })
6825 } else {
6826 None
6827 }
6828 }
6829 }
6830
6831 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
6832 where
6833 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6834 ___D: ::fidl_next::Decoder<'de>,
6835 ___D: ::fidl_next::fuchsia::HandleDecoder,
6836 {
6837 fn decode(
6838 mut slot: ::fidl_next::Slot<'_, Self>,
6839 decoder: &mut ___D,
6840 _: (),
6841 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6842 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6843 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6844 1 => ::fidl_next::wire::Union::decode_as::<
6845 ___D,
6846 crate::wire::CapabilityRequestedPayload<'de>,
6847 >(raw, decoder, ())?,
6848
6849 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
6850 raw,
6851 decoder,
6852 (),
6853 )?,
6854
6855 4 => ::fidl_next::wire::Union::decode_as::<
6856 ___D,
6857 crate::wire::DiscoveredPayload<'de>,
6858 >(raw, decoder, ())?,
6859
6860 5 => {
6861 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
6862 raw,
6863 decoder,
6864 (),
6865 )?
6866 }
6867
6868 6 => {
6869 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
6870 raw,
6871 decoder,
6872 (),
6873 )?
6874 }
6875
6876 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
6877 raw,
6878 decoder,
6879 (),
6880 )?,
6881
6882 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
6883 raw,
6884 decoder,
6885 (),
6886 )?,
6887
6888 9 => ::fidl_next::wire::Union::decode_as::<
6889 ___D,
6890 crate::wire::DebugStartedPayload<'de>,
6891 >(raw, decoder, ())?,
6892
6893 10 => ::fidl_next::wire::Union::decode_as::<
6894 ___D,
6895 crate::wire::UnresolvedPayload<'de>,
6896 >(raw, decoder, ())?,
6897
6898 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
6899 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
6900 }
6901
6902 Ok(())
6903 }
6904 }
6905
6906 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
6907 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6908 self.as_ref().fmt(f)
6909 }
6910 }
6911
6912 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
6913 type Natural = ::core::option::Option<crate::natural::EventPayload>;
6914 }
6915}
6916
6917pub mod generic {
6918
6919 pub use fidl_next_common_fuchsia_component::generic::*;
6920
6921 pub struct ControllerIsStartedResponse<T0> {
6923 pub is_started: T0,
6924 }
6925
6926 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6927 for ControllerIsStartedResponse<T0>
6928 where
6929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6930 ___E: ::fidl_next::fuchsia::HandleEncoder,
6931 T0: ::fidl_next::Encode<bool, ___E>,
6932 {
6933 #[inline]
6934 fn encode(
6935 self,
6936 encoder_: &mut ___E,
6937 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6938 _: (),
6939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6940 ::fidl_next::munge! {
6941 let crate::wire::ControllerIsStartedResponse {
6942 is_started,
6943
6944 } = out_;
6945 }
6946
6947 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
6948
6949 Ok(())
6950 }
6951 }
6952
6953 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6954 for &'a ControllerIsStartedResponse<T0>
6955 where
6956 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6957 ___E: ::fidl_next::fuchsia::HandleEncoder,
6958 &'a T0: ::fidl_next::Encode<bool, ___E>,
6959 {
6960 #[inline]
6961 fn encode(
6962 self,
6963 encoder_: &mut ___E,
6964 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6965 _: (),
6966 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6967 ::fidl_next::munge! {
6968 let crate::wire::ControllerIsStartedResponse {
6969 is_started,
6970
6971 } = out_;
6972 }
6973
6974 ::fidl_next::Encode::encode(&self.is_started, encoder_, is_started, ())?;
6975
6976 Ok(())
6977 }
6978 }
6979
6980 pub struct ControllerGetExposedDictionaryResponse<T0> {
6982 pub dictionary: T0,
6983 }
6984
6985 unsafe impl<___E, T0>
6986 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
6987 for ControllerGetExposedDictionaryResponse<T0>
6988 where
6989 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6990 ___E: ::fidl_next::fuchsia::HandleEncoder,
6991 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
6992 {
6993 #[inline]
6994 fn encode(
6995 self,
6996 encoder_: &mut ___E,
6997 out_: &mut ::core::mem::MaybeUninit<
6998 crate::wire::ControllerGetExposedDictionaryResponse,
6999 >,
7000 _: (),
7001 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7002 ::fidl_next::munge! {
7003 let crate::wire::ControllerGetExposedDictionaryResponse {
7004 dictionary,
7005
7006 } = out_;
7007 }
7008
7009 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7010
7011 Ok(())
7012 }
7013 }
7014
7015 unsafe impl<'a, ___E, T0>
7016 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
7017 for &'a ControllerGetExposedDictionaryResponse<T0>
7018 where
7019 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7020 ___E: ::fidl_next::fuchsia::HandleEncoder,
7021 &'a T0:
7022 ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
7023 {
7024 #[inline]
7025 fn encode(
7026 self,
7027 encoder_: &mut ___E,
7028 out_: &mut ::core::mem::MaybeUninit<
7029 crate::wire::ControllerGetExposedDictionaryResponse,
7030 >,
7031 _: (),
7032 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7033 ::fidl_next::munge! {
7034 let crate::wire::ControllerGetExposedDictionaryResponse {
7035 dictionary,
7036
7037 } = out_;
7038 }
7039
7040 ::fidl_next::Encode::encode(&self.dictionary, encoder_, dictionary, ())?;
7041
7042 Ok(())
7043 }
7044 }
7045
7046 pub struct ControllerGetOutputDictionaryResponse<T0> {
7048 pub dictionary: T0,
7049 }
7050
7051 unsafe impl<___E, T0>
7052 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
7053 for ControllerGetOutputDictionaryResponse<T0>
7054 where
7055 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7056 ___E: ::fidl_next::fuchsia::HandleEncoder,
7057 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7058 {
7059 #[inline]
7060 fn encode(
7061 self,
7062 encoder_: &mut ___E,
7063 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
7064 _: (),
7065 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7066 ::fidl_next::munge! {
7067 let crate::wire::ControllerGetOutputDictionaryResponse {
7068 dictionary,
7069
7070 } = out_;
7071 }
7072
7073 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7074
7075 Ok(())
7076 }
7077 }
7078
7079 unsafe impl<'a, ___E, T0>
7080 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
7081 for &'a ControllerGetOutputDictionaryResponse<T0>
7082 where
7083 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7084 ___E: ::fidl_next::fuchsia::HandleEncoder,
7085 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7086 {
7087 #[inline]
7088 fn encode(
7089 self,
7090 encoder_: &mut ___E,
7091 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
7092 _: (),
7093 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7094 ::fidl_next::munge! {
7095 let crate::wire::ControllerGetOutputDictionaryResponse {
7096 dictionary,
7097
7098 } = out_;
7099 }
7100
7101 ::fidl_next::Encode::encode(&self.dictionary, encoder_, dictionary, ())?;
7102
7103 Ok(())
7104 }
7105 }
7106
7107 pub struct ControllerStartRequest<T0, T1> {
7109 pub args: T0,
7110
7111 pub execution_controller: T1,
7112 }
7113
7114 unsafe impl<___E, T0, T1>
7115 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
7116 for ControllerStartRequest<T0, T1>
7117 where
7118 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7119 ___E: ::fidl_next::Encoder,
7120 ___E: ::fidl_next::fuchsia::HandleEncoder,
7121 T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
7122 T1: ::fidl_next::Encode<
7123 ::fidl_next::ServerEnd<
7124 crate::ExecutionController,
7125 ::fidl_next::wire::fuchsia::Channel,
7126 >,
7127 ___E,
7128 >,
7129 {
7130 #[inline]
7131 fn encode(
7132 self,
7133 encoder_: &mut ___E,
7134 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
7135 _: (),
7136 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7137 ::fidl_next::munge! {
7138 let crate::wire::ControllerStartRequest {
7139 args,
7140 execution_controller,
7141
7142 } = out_;
7143 }
7144
7145 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7146
7147 ::fidl_next::Encode::encode(
7148 self.execution_controller,
7149 encoder_,
7150 execution_controller,
7151 (),
7152 )?;
7153
7154 Ok(())
7155 }
7156 }
7157
7158 unsafe impl<'a, ___E, T0, T1>
7159 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
7160 for &'a ControllerStartRequest<T0, T1>
7161 where
7162 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7163 ___E: ::fidl_next::Encoder,
7164 ___E: ::fidl_next::fuchsia::HandleEncoder,
7165 &'a T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
7166 &'a T1: ::fidl_next::Encode<
7167 ::fidl_next::ServerEnd<
7168 crate::ExecutionController,
7169 ::fidl_next::wire::fuchsia::Channel,
7170 >,
7171 ___E,
7172 >,
7173 {
7174 #[inline]
7175 fn encode(
7176 self,
7177 encoder_: &mut ___E,
7178 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
7179 _: (),
7180 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7181 ::fidl_next::munge! {
7182 let crate::wire::ControllerStartRequest {
7183 args,
7184 execution_controller,
7185
7186 } = out_;
7187 }
7188
7189 ::fidl_next::Encode::encode(&self.args, encoder_, args, ())?;
7190
7191 ::fidl_next::Encode::encode(
7192 &self.execution_controller,
7193 encoder_,
7194 execution_controller,
7195 (),
7196 )?;
7197
7198 Ok(())
7199 }
7200 }
7201
7202 pub struct ControllerOpenExposedDirRequest<T0> {
7204 pub exposed_dir: T0,
7205 }
7206
7207 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
7208 for ControllerOpenExposedDirRequest<T0>
7209 where
7210 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7211 ___E: ::fidl_next::fuchsia::HandleEncoder,
7212 T0: ::fidl_next::Encode<
7213 ::fidl_next::ServerEnd<
7214 ::fidl_next_fuchsia_io::Directory,
7215 ::fidl_next::wire::fuchsia::Channel,
7216 >,
7217 ___E,
7218 >,
7219 {
7220 #[inline]
7221 fn encode(
7222 self,
7223 encoder_: &mut ___E,
7224 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
7225 _: (),
7226 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7227 ::fidl_next::munge! {
7228 let crate::wire::ControllerOpenExposedDirRequest {
7229 exposed_dir,
7230
7231 } = out_;
7232 }
7233
7234 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7235
7236 Ok(())
7237 }
7238 }
7239
7240 unsafe impl<'a, ___E, T0>
7241 ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
7242 for &'a ControllerOpenExposedDirRequest<T0>
7243 where
7244 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7245 ___E: ::fidl_next::fuchsia::HandleEncoder,
7246 &'a T0: ::fidl_next::Encode<
7247 ::fidl_next::ServerEnd<
7248 ::fidl_next_fuchsia_io::Directory,
7249 ::fidl_next::wire::fuchsia::Channel,
7250 >,
7251 ___E,
7252 >,
7253 {
7254 #[inline]
7255 fn encode(
7256 self,
7257 encoder_: &mut ___E,
7258 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
7259 _: (),
7260 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7261 ::fidl_next::munge! {
7262 let crate::wire::ControllerOpenExposedDirRequest {
7263 exposed_dir,
7264
7265 } = out_;
7266 }
7267
7268 ::fidl_next::Encode::encode(&self.exposed_dir, encoder_, exposed_dir, ())?;
7269
7270 Ok(())
7271 }
7272 }
7273
7274 pub struct EventStreamGetNextResponse<T0> {
7276 pub events: T0,
7277 }
7278
7279 unsafe impl<___E, T0>
7280 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
7281 for EventStreamGetNextResponse<T0>
7282 where
7283 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7284 ___E: ::fidl_next::Encoder,
7285 ___E: ::fidl_next::fuchsia::HandleEncoder,
7286 T0: ::fidl_next::Encode<
7287 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
7288 ___E,
7289 >,
7290 {
7291 #[inline]
7292 fn encode(
7293 self,
7294 encoder_: &mut ___E,
7295 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
7296 _: (),
7297 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7298 ::fidl_next::munge! {
7299 let crate::wire::EventStreamGetNextResponse {
7300 events,
7301
7302 } = out_;
7303 }
7304
7305 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
7306
7307 Ok(())
7308 }
7309 }
7310
7311 unsafe impl<'a, ___E, T0>
7312 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
7313 for &'a EventStreamGetNextResponse<T0>
7314 where
7315 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7316 ___E: ::fidl_next::Encoder,
7317 ___E: ::fidl_next::fuchsia::HandleEncoder,
7318 &'a T0: ::fidl_next::Encode<
7319 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
7320 ___E,
7321 >,
7322 {
7323 #[inline]
7324 fn encode(
7325 self,
7326 encoder_: &mut ___E,
7327 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
7328 _: (),
7329 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7330 ::fidl_next::munge! {
7331 let crate::wire::EventStreamGetNextResponse {
7332 events,
7333
7334 } = out_;
7335 }
7336
7337 ::fidl_next::Encode::encode(&self.events, encoder_, events, (4294967295, ()))?;
7338
7339 Ok(())
7340 }
7341 }
7342
7343 pub struct IntrospectorGetMonikerRequest<T0> {
7345 pub component_instance: T0,
7346 }
7347
7348 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
7349 for IntrospectorGetMonikerRequest<T0>
7350 where
7351 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7352 ___E: ::fidl_next::fuchsia::HandleEncoder,
7353 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
7354 {
7355 #[inline]
7356 fn encode(
7357 self,
7358 encoder_: &mut ___E,
7359 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
7360 _: (),
7361 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7362 ::fidl_next::munge! {
7363 let crate::wire::IntrospectorGetMonikerRequest {
7364 component_instance,
7365
7366 } = out_;
7367 }
7368
7369 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
7370
7371 Ok(())
7372 }
7373 }
7374
7375 unsafe impl<'a, ___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
7376 for &'a IntrospectorGetMonikerRequest<T0>
7377 where
7378 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7379 ___E: ::fidl_next::fuchsia::HandleEncoder,
7380 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
7381 {
7382 #[inline]
7383 fn encode(
7384 self,
7385 encoder_: &mut ___E,
7386 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
7387 _: (),
7388 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7389 ::fidl_next::munge! {
7390 let crate::wire::IntrospectorGetMonikerRequest {
7391 component_instance,
7392
7393 } = out_;
7394 }
7395
7396 ::fidl_next::Encode::encode(
7397 &self.component_instance,
7398 encoder_,
7399 component_instance,
7400 (),
7401 )?;
7402
7403 Ok(())
7404 }
7405 }
7406
7407 pub struct NamespaceInputEntry<T0, T1> {
7409 pub path: T0,
7410
7411 pub dictionary: T1,
7412 }
7413
7414 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7415 for NamespaceInputEntry<T0, T1>
7416 where
7417 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7418 ___E: ::fidl_next::Encoder,
7419 ___E: ::fidl_next::fuchsia::HandleEncoder,
7420 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7421 T1: ::fidl_next::Encode<
7422 ::fidl_next::ClientEnd<
7423 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7424 ::fidl_next::wire::fuchsia::Channel,
7425 >,
7426 ___E,
7427 >,
7428 {
7429 #[inline]
7430 fn encode(
7431 self,
7432 encoder_: &mut ___E,
7433 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7434 _: (),
7435 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7436 ::fidl_next::munge! {
7437 let crate::wire::NamespaceInputEntry {
7438 path,
7439 dictionary,
7440
7441 } = out_;
7442 }
7443
7444 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7445
7446 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7447
7448 Ok(())
7449 }
7450 }
7451
7452 unsafe impl<'a, ___E, T0, T1>
7453 ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7454 for &'a NamespaceInputEntry<T0, T1>
7455 where
7456 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7457 ___E: ::fidl_next::Encoder,
7458 ___E: ::fidl_next::fuchsia::HandleEncoder,
7459 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7460 &'a T1: ::fidl_next::Encode<
7461 ::fidl_next::ClientEnd<
7462 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7463 ::fidl_next::wire::fuchsia::Channel,
7464 >,
7465 ___E,
7466 >,
7467 {
7468 #[inline]
7469 fn encode(
7470 self,
7471 encoder_: &mut ___E,
7472 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7473 _: (),
7474 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7475 ::fidl_next::munge! {
7476 let crate::wire::NamespaceInputEntry {
7477 path,
7478 dictionary,
7479
7480 } = out_;
7481 }
7482
7483 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
7484
7485 ::fidl_next::Encode::encode(&self.dictionary, encoder_, dictionary, ())?;
7486
7487 Ok(())
7488 }
7489 }
7490
7491 pub struct NamespaceCreateRequest<T0> {
7493 pub entries: T0,
7494 }
7495
7496 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7497 for NamespaceCreateRequest<T0>
7498 where
7499 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7500 ___E: ::fidl_next::Encoder,
7501 ___E: ::fidl_next::fuchsia::HandleEncoder,
7502 T0: ::fidl_next::Encode<
7503 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7504 ___E,
7505 >,
7506 {
7507 #[inline]
7508 fn encode(
7509 self,
7510 encoder_: &mut ___E,
7511 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7512 _: (),
7513 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7514 ::fidl_next::munge! {
7515 let crate::wire::NamespaceCreateRequest {
7516 entries,
7517
7518 } = out_;
7519 }
7520
7521 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7522
7523 Ok(())
7524 }
7525 }
7526
7527 unsafe impl<'a, ___E, T0>
7528 ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7529 for &'a NamespaceCreateRequest<T0>
7530 where
7531 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7532 ___E: ::fidl_next::Encoder,
7533 ___E: ::fidl_next::fuchsia::HandleEncoder,
7534 &'a T0: ::fidl_next::Encode<
7535 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7536 ___E,
7537 >,
7538 {
7539 #[inline]
7540 fn encode(
7541 self,
7542 encoder_: &mut ___E,
7543 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7544 _: (),
7545 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7546 ::fidl_next::munge! {
7547 let crate::wire::NamespaceCreateRequest {
7548 entries,
7549
7550 } = out_;
7551 }
7552
7553 ::fidl_next::Encode::encode(&self.entries, encoder_, entries, (4294967295, ()))?;
7554
7555 Ok(())
7556 }
7557 }
7558
7559 pub struct NamespaceInputEntry2<T0, T1> {
7561 pub path: T0,
7562
7563 pub capability: T1,
7564 }
7565
7566 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7567 for NamespaceInputEntry2<T0, T1>
7568 where
7569 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7570 ___E: ::fidl_next::Encoder,
7571 ___E: ::fidl_next::fuchsia::HandleEncoder,
7572 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7573 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7574 {
7575 #[inline]
7576 fn encode(
7577 self,
7578 encoder_: &mut ___E,
7579 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7580 _: (),
7581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7582 ::fidl_next::munge! {
7583 let crate::wire::NamespaceInputEntry2 {
7584 path,
7585 capability,
7586
7587 } = out_;
7588 }
7589
7590 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7591
7592 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7593
7594 Ok(())
7595 }
7596 }
7597
7598 unsafe impl<'a, ___E, T0, T1>
7599 ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7600 for &'a NamespaceInputEntry2<T0, T1>
7601 where
7602 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7603 ___E: ::fidl_next::Encoder,
7604 ___E: ::fidl_next::fuchsia::HandleEncoder,
7605 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7606 &'a T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7607 {
7608 #[inline]
7609 fn encode(
7610 self,
7611 encoder_: &mut ___E,
7612 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7613 _: (),
7614 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7615 ::fidl_next::munge! {
7616 let crate::wire::NamespaceInputEntry2 {
7617 path,
7618 capability,
7619
7620 } = out_;
7621 }
7622
7623 ::fidl_next::Encode::encode(&self.path, encoder_, path, 4095)?;
7624
7625 ::fidl_next::Encode::encode(&self.capability, encoder_, capability, ())?;
7626
7627 Ok(())
7628 }
7629 }
7630
7631 pub struct NamespaceCreate2Request<T0> {
7633 pub entries: T0,
7634 }
7635
7636 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7637 for NamespaceCreate2Request<T0>
7638 where
7639 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7640 ___E: ::fidl_next::Encoder,
7641 ___E: ::fidl_next::fuchsia::HandleEncoder,
7642 T0: ::fidl_next::Encode<
7643 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7644 ___E,
7645 >,
7646 {
7647 #[inline]
7648 fn encode(
7649 self,
7650 encoder_: &mut ___E,
7651 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7652 _: (),
7653 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7654 ::fidl_next::munge! {
7655 let crate::wire::NamespaceCreate2Request {
7656 entries,
7657
7658 } = out_;
7659 }
7660
7661 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7662
7663 Ok(())
7664 }
7665 }
7666
7667 unsafe impl<'a, ___E, T0>
7668 ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7669 for &'a NamespaceCreate2Request<T0>
7670 where
7671 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7672 ___E: ::fidl_next::Encoder,
7673 ___E: ::fidl_next::fuchsia::HandleEncoder,
7674 &'a T0: ::fidl_next::Encode<
7675 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7676 ___E,
7677 >,
7678 {
7679 #[inline]
7680 fn encode(
7681 self,
7682 encoder_: &mut ___E,
7683 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7684 _: (),
7685 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7686 ::fidl_next::munge! {
7687 let crate::wire::NamespaceCreate2Request {
7688 entries,
7689
7690 } = out_;
7691 }
7692
7693 ::fidl_next::Encode::encode(&self.entries, encoder_, entries, (4294967295, ()))?;
7694
7695 Ok(())
7696 }
7697 }
7698
7699 pub struct NamespaceCreateResponse<T0> {
7701 pub entries: T0,
7702 }
7703
7704 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7705 for NamespaceCreateResponse<T0>
7706 where
7707 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7708 ___E: ::fidl_next::Encoder,
7709 ___E: ::fidl_next::fuchsia::HandleEncoder,
7710 T0: ::fidl_next::Encode<
7711 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7712 ___E,
7713 >,
7714 {
7715 #[inline]
7716 fn encode(
7717 self,
7718 encoder_: &mut ___E,
7719 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7720 _: (),
7721 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7722 ::fidl_next::munge! {
7723 let crate::wire::NamespaceCreateResponse {
7724 entries,
7725
7726 } = out_;
7727 }
7728
7729 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7730
7731 Ok(())
7732 }
7733 }
7734
7735 unsafe impl<'a, ___E, T0>
7736 ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7737 for &'a NamespaceCreateResponse<T0>
7738 where
7739 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7740 ___E: ::fidl_next::Encoder,
7741 ___E: ::fidl_next::fuchsia::HandleEncoder,
7742 &'a T0: ::fidl_next::Encode<
7743 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7744 ___E,
7745 >,
7746 {
7747 #[inline]
7748 fn encode(
7749 self,
7750 encoder_: &mut ___E,
7751 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7752 _: (),
7753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7754 ::fidl_next::munge! {
7755 let crate::wire::NamespaceCreateResponse {
7756 entries,
7757
7758 } = out_;
7759 }
7760
7761 ::fidl_next::Encode::encode(&self.entries, encoder_, entries, (4294967295, ()))?;
7762
7763 Ok(())
7764 }
7765 }
7766
7767 pub struct NamespaceCreate2Response<T0> {
7769 pub entries: T0,
7770 }
7771
7772 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7773 for NamespaceCreate2Response<T0>
7774 where
7775 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7776 ___E: ::fidl_next::Encoder,
7777 ___E: ::fidl_next::fuchsia::HandleEncoder,
7778 T0: ::fidl_next::Encode<
7779 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7780 ___E,
7781 >,
7782 {
7783 #[inline]
7784 fn encode(
7785 self,
7786 encoder_: &mut ___E,
7787 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7788 _: (),
7789 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7790 ::fidl_next::munge! {
7791 let crate::wire::NamespaceCreate2Response {
7792 entries,
7793
7794 } = out_;
7795 }
7796
7797 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7798
7799 Ok(())
7800 }
7801 }
7802
7803 unsafe impl<'a, ___E, T0>
7804 ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7805 for &'a NamespaceCreate2Response<T0>
7806 where
7807 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7808 ___E: ::fidl_next::Encoder,
7809 ___E: ::fidl_next::fuchsia::HandleEncoder,
7810 &'a T0: ::fidl_next::Encode<
7811 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7812 ___E,
7813 >,
7814 {
7815 #[inline]
7816 fn encode(
7817 self,
7818 encoder_: &mut ___E,
7819 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7820 _: (),
7821 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7822 ::fidl_next::munge! {
7823 let crate::wire::NamespaceCreate2Response {
7824 entries,
7825
7826 } = out_;
7827 }
7828
7829 ::fidl_next::Encode::encode(&self.entries, encoder_, entries, (4294967295, ()))?;
7830
7831 Ok(())
7832 }
7833 }
7834
7835 pub struct RealmListChildrenRequest<T0, T1> {
7837 pub collection: T0,
7838
7839 pub iter: T1,
7840 }
7841
7842 unsafe impl<___E, T0, T1>
7843 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7844 for RealmListChildrenRequest<T0, T1>
7845 where
7846 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7847 ___E: ::fidl_next::Encoder,
7848 ___E: ::fidl_next::fuchsia::HandleEncoder,
7849 T0: ::fidl_next::Encode<
7850 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7851 ___E,
7852 >,
7853 T1: ::fidl_next::Encode<
7854 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7855 ___E,
7856 >,
7857 {
7858 #[inline]
7859 fn encode(
7860 self,
7861 encoder_: &mut ___E,
7862 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7863 _: (),
7864 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7865 ::fidl_next::munge! {
7866 let crate::wire::RealmListChildrenRequest {
7867 collection,
7868 iter,
7869
7870 } = out_;
7871 }
7872
7873 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7874
7875 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
7876
7877 Ok(())
7878 }
7879 }
7880
7881 unsafe impl<'a, ___E, T0, T1>
7882 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7883 for &'a RealmListChildrenRequest<T0, T1>
7884 where
7885 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7886 ___E: ::fidl_next::Encoder,
7887 ___E: ::fidl_next::fuchsia::HandleEncoder,
7888 &'a T0: ::fidl_next::Encode<
7889 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7890 ___E,
7891 >,
7892 &'a T1: ::fidl_next::Encode<
7893 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7894 ___E,
7895 >,
7896 {
7897 #[inline]
7898 fn encode(
7899 self,
7900 encoder_: &mut ___E,
7901 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7902 _: (),
7903 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7904 ::fidl_next::munge! {
7905 let crate::wire::RealmListChildrenRequest {
7906 collection,
7907 iter,
7908
7909 } = out_;
7910 }
7911
7912 ::fidl_next::Encode::encode(&self.collection, encoder_, collection, ())?;
7913
7914 ::fidl_next::Encode::encode(&self.iter, encoder_, iter, ())?;
7915
7916 Ok(())
7917 }
7918 }
7919
7920 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<T0> {
7922 pub child: T0,
7923 }
7924
7925 unsafe impl<___E, T0>
7926 ::fidl_next::Encode<
7927 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7928 ___E,
7929 > for RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7930 where
7931 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7932 ___E: ::fidl_next::Encoder,
7933 ___E: ::fidl_next::fuchsia::HandleEncoder,
7934 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7935 {
7936 #[inline]
7937 fn encode(
7938 self,
7939 encoder_: &mut ___E,
7940 out_: &mut ::core::mem::MaybeUninit<
7941 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7942 >,
7943 _: (),
7944 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7945 ::fidl_next::munge! {
7946 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7947 child,
7948
7949 } = out_;
7950 }
7951
7952 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7953
7954 Ok(())
7955 }
7956 }
7957
7958 unsafe impl<'a, ___E, T0>
7959 ::fidl_next::Encode<
7960 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7961 ___E,
7962 > for &'a RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7963 where
7964 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7965 ___E: ::fidl_next::Encoder,
7966 ___E: ::fidl_next::fuchsia::HandleEncoder,
7967 &'a T0:
7968 ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7969 {
7970 #[inline]
7971 fn encode(
7972 self,
7973 encoder_: &mut ___E,
7974 out_: &mut ::core::mem::MaybeUninit<
7975 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7976 >,
7977 _: (),
7978 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7979 ::fidl_next::munge! {
7980 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7981 child,
7982
7983 } = out_;
7984 }
7985
7986 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
7987
7988 Ok(())
7989 }
7990 }
7991
7992 pub struct RealmGetChildOutputDictionaryDeprecatedResponse<T0> {
7994 pub dictionary: T0,
7995 }
7996
7997 unsafe impl<___E, T0>
7998 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
7999 for RealmGetChildOutputDictionaryDeprecatedResponse<T0>
8000 where
8001 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8002 ___E: ::fidl_next::fuchsia::HandleEncoder,
8003 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
8004 {
8005 #[inline]
8006 fn encode(
8007 self,
8008 encoder_: &mut ___E,
8009 out_: &mut ::core::mem::MaybeUninit<
8010 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
8011 >,
8012 _: (),
8013 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8014 ::fidl_next::munge! {
8015 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
8016 dictionary,
8017
8018 } = out_;
8019 }
8020
8021 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
8022
8023 Ok(())
8024 }
8025 }
8026
8027 unsafe impl<'a, ___E, T0>
8028 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
8029 for &'a RealmGetChildOutputDictionaryDeprecatedResponse<T0>
8030 where
8031 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8032 ___E: ::fidl_next::fuchsia::HandleEncoder,
8033 &'a T0:
8034 ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
8035 {
8036 #[inline]
8037 fn encode(
8038 self,
8039 encoder_: &mut ___E,
8040 out_: &mut ::core::mem::MaybeUninit<
8041 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
8042 >,
8043 _: (),
8044 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8045 ::fidl_next::munge! {
8046 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
8047 dictionary,
8048
8049 } = out_;
8050 }
8051
8052 ::fidl_next::Encode::encode(&self.dictionary, encoder_, dictionary, ())?;
8053
8054 Ok(())
8055 }
8056 }
8057
8058 pub struct RealmGetChildOutputDictionaryRequest<T0> {
8060 pub child: T0,
8061 }
8062
8063 unsafe impl<___E, T0>
8064 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
8065 for RealmGetChildOutputDictionaryRequest<T0>
8066 where
8067 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8068 ___E: ::fidl_next::Encoder,
8069 ___E: ::fidl_next::fuchsia::HandleEncoder,
8070 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8071 {
8072 #[inline]
8073 fn encode(
8074 self,
8075 encoder_: &mut ___E,
8076 out_: &mut ::core::mem::MaybeUninit<
8077 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
8078 >,
8079 _: (),
8080 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8081 ::fidl_next::munge! {
8082 let crate::wire::RealmGetChildOutputDictionaryRequest {
8083 child,
8084
8085 } = out_;
8086 }
8087
8088 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
8089
8090 Ok(())
8091 }
8092 }
8093
8094 unsafe impl<'a, ___E, T0>
8095 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
8096 for &'a RealmGetChildOutputDictionaryRequest<T0>
8097 where
8098 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8099 ___E: ::fidl_next::Encoder,
8100 ___E: ::fidl_next::fuchsia::HandleEncoder,
8101 &'a T0:
8102 ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8103 {
8104 #[inline]
8105 fn encode(
8106 self,
8107 encoder_: &mut ___E,
8108 out_: &mut ::core::mem::MaybeUninit<
8109 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
8110 >,
8111 _: (),
8112 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8113 ::fidl_next::munge! {
8114 let crate::wire::RealmGetChildOutputDictionaryRequest {
8115 child,
8116
8117 } = out_;
8118 }
8119
8120 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
8121
8122 Ok(())
8123 }
8124 }
8125
8126 pub struct RealmGetChildOutputDictionaryResponse<T0> {
8128 pub dictionary: T0,
8129 }
8130
8131 unsafe impl<___E, T0>
8132 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
8133 for RealmGetChildOutputDictionaryResponse<T0>
8134 where
8135 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8136 ___E: ::fidl_next::fuchsia::HandleEncoder,
8137 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8138 {
8139 #[inline]
8140 fn encode(
8141 self,
8142 encoder_: &mut ___E,
8143 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
8144 _: (),
8145 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8146 ::fidl_next::munge! {
8147 let crate::wire::RealmGetChildOutputDictionaryResponse {
8148 dictionary,
8149
8150 } = out_;
8151 }
8152
8153 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
8154
8155 Ok(())
8156 }
8157 }
8158
8159 unsafe impl<'a, ___E, T0>
8160 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
8161 for &'a RealmGetChildOutputDictionaryResponse<T0>
8162 where
8163 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8164 ___E: ::fidl_next::fuchsia::HandleEncoder,
8165 &'a T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
8166 {
8167 #[inline]
8168 fn encode(
8169 self,
8170 encoder_: &mut ___E,
8171 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
8172 _: (),
8173 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8174 ::fidl_next::munge! {
8175 let crate::wire::RealmGetChildOutputDictionaryResponse {
8176 dictionary,
8177
8178 } = out_;
8179 }
8180
8181 ::fidl_next::Encode::encode(&self.dictionary, encoder_, dictionary, ())?;
8182
8183 Ok(())
8184 }
8185 }
8186
8187 pub struct RealmOpenControllerRequest<T0, T1> {
8189 pub child: T0,
8190
8191 pub controller: T1,
8192 }
8193
8194 unsafe impl<___E, T0, T1>
8195 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
8196 for RealmOpenControllerRequest<T0, T1>
8197 where
8198 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8199 ___E: ::fidl_next::Encoder,
8200 ___E: ::fidl_next::fuchsia::HandleEncoder,
8201 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8202 T1: ::fidl_next::Encode<
8203 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
8204 ___E,
8205 >,
8206 {
8207 #[inline]
8208 fn encode(
8209 self,
8210 encoder_: &mut ___E,
8211 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
8212 _: (),
8213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8214 ::fidl_next::munge! {
8215 let crate::wire::RealmOpenControllerRequest {
8216 child,
8217 controller,
8218
8219 } = out_;
8220 }
8221
8222 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
8223
8224 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
8225
8226 Ok(())
8227 }
8228 }
8229
8230 unsafe impl<'a, ___E, T0, T1>
8231 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
8232 for &'a RealmOpenControllerRequest<T0, T1>
8233 where
8234 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8235 ___E: ::fidl_next::Encoder,
8236 ___E: ::fidl_next::fuchsia::HandleEncoder,
8237 &'a T0:
8238 ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8239 &'a T1: ::fidl_next::Encode<
8240 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
8241 ___E,
8242 >,
8243 {
8244 #[inline]
8245 fn encode(
8246 self,
8247 encoder_: &mut ___E,
8248 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
8249 _: (),
8250 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8251 ::fidl_next::munge! {
8252 let crate::wire::RealmOpenControllerRequest {
8253 child,
8254 controller,
8255
8256 } = out_;
8257 }
8258
8259 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
8260
8261 ::fidl_next::Encode::encode(&self.controller, encoder_, controller, ())?;
8262
8263 Ok(())
8264 }
8265 }
8266
8267 pub struct RealmOpenExposedDirRequest<T0, T1> {
8269 pub child: T0,
8270
8271 pub exposed_dir: T1,
8272 }
8273
8274 unsafe impl<___E, T0, T1>
8275 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
8276 for RealmOpenExposedDirRequest<T0, T1>
8277 where
8278 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8279 ___E: ::fidl_next::Encoder,
8280 ___E: ::fidl_next::fuchsia::HandleEncoder,
8281 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8282 T1: ::fidl_next::Encode<
8283 ::fidl_next::ServerEnd<
8284 ::fidl_next_fuchsia_io::Directory,
8285 ::fidl_next::wire::fuchsia::Channel,
8286 >,
8287 ___E,
8288 >,
8289 {
8290 #[inline]
8291 fn encode(
8292 self,
8293 encoder_: &mut ___E,
8294 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
8295 _: (),
8296 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8297 ::fidl_next::munge! {
8298 let crate::wire::RealmOpenExposedDirRequest {
8299 child,
8300 exposed_dir,
8301
8302 } = out_;
8303 }
8304
8305 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
8306
8307 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
8308
8309 Ok(())
8310 }
8311 }
8312
8313 unsafe impl<'a, ___E, T0, T1>
8314 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
8315 for &'a RealmOpenExposedDirRequest<T0, T1>
8316 where
8317 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8318 ___E: ::fidl_next::Encoder,
8319 ___E: ::fidl_next::fuchsia::HandleEncoder,
8320 &'a T0:
8321 ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
8322 &'a T1: ::fidl_next::Encode<
8323 ::fidl_next::ServerEnd<
8324 ::fidl_next_fuchsia_io::Directory,
8325 ::fidl_next::wire::fuchsia::Channel,
8326 >,
8327 ___E,
8328 >,
8329 {
8330 #[inline]
8331 fn encode(
8332 self,
8333 encoder_: &mut ___E,
8334 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
8335 _: (),
8336 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8337 ::fidl_next::munge! {
8338 let crate::wire::RealmOpenExposedDirRequest {
8339 child,
8340 exposed_dir,
8341
8342 } = out_;
8343 }
8344
8345 ::fidl_next::Encode::encode(&self.child, encoder_, child, ())?;
8346
8347 ::fidl_next::Encode::encode(&self.exposed_dir, encoder_, exposed_dir, ())?;
8348
8349 Ok(())
8350 }
8351 }
8352
8353 pub struct RealmCreateChildRequest<T0, T1, T2> {
8355 pub collection: T0,
8356
8357 pub decl: T1,
8358
8359 pub args: T2,
8360 }
8361
8362 unsafe impl<___E, T0, T1, T2>
8363 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
8364 for RealmCreateChildRequest<T0, T1, T2>
8365 where
8366 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8367 ___E: ::fidl_next::Encoder,
8368 ___E: ::fidl_next::fuchsia::HandleEncoder,
8369 T0: ::fidl_next::Encode<
8370 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
8371 ___E,
8372 >,
8373 T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
8374 T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
8375 {
8376 #[inline]
8377 fn encode(
8378 self,
8379 encoder_: &mut ___E,
8380 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
8381 _: (),
8382 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8383 ::fidl_next::munge! {
8384 let crate::wire::RealmCreateChildRequest {
8385 collection,
8386 decl,
8387 args,
8388
8389 } = out_;
8390 }
8391
8392 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
8393
8394 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
8395
8396 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
8397
8398 Ok(())
8399 }
8400 }
8401
8402 unsafe impl<'a, ___E, T0, T1, T2>
8403 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
8404 for &'a RealmCreateChildRequest<T0, T1, T2>
8405 where
8406 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8407 ___E: ::fidl_next::Encoder,
8408 ___E: ::fidl_next::fuchsia::HandleEncoder,
8409 &'a T0: ::fidl_next::Encode<
8410 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
8411 ___E,
8412 >,
8413 &'a T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
8414 &'a T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
8415 {
8416 #[inline]
8417 fn encode(
8418 self,
8419 encoder_: &mut ___E,
8420 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
8421 _: (),
8422 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8423 ::fidl_next::munge! {
8424 let crate::wire::RealmCreateChildRequest {
8425 collection,
8426 decl,
8427 args,
8428
8429 } = out_;
8430 }
8431
8432 ::fidl_next::Encode::encode(&self.collection, encoder_, collection, ())?;
8433
8434 ::fidl_next::Encode::encode(&self.decl, encoder_, decl, ())?;
8435
8436 ::fidl_next::Encode::encode(&self.args, encoder_, args, ())?;
8437
8438 Ok(())
8439 }
8440 }
8441
8442 pub struct RealmGetResolvedInfoResponse<T0> {
8444 pub resolved_info: T0,
8445 }
8446
8447 unsafe impl<___E, T0>
8448 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
8449 for RealmGetResolvedInfoResponse<T0>
8450 where
8451 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8452 ___E: ::fidl_next::Encoder,
8453 ___E: ::fidl_next::fuchsia::HandleEncoder,
8454 T0: ::fidl_next::Encode<
8455 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
8456 ___E,
8457 >,
8458 {
8459 #[inline]
8460 fn encode(
8461 self,
8462 encoder_: &mut ___E,
8463 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
8464 _: (),
8465 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8466 ::fidl_next::munge! {
8467 let crate::wire::RealmGetResolvedInfoResponse {
8468 resolved_info,
8469
8470 } = out_;
8471 }
8472
8473 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
8474
8475 Ok(())
8476 }
8477 }
8478
8479 unsafe impl<'a, ___E, T0>
8480 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
8481 for &'a RealmGetResolvedInfoResponse<T0>
8482 where
8483 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8484 ___E: ::fidl_next::Encoder,
8485 ___E: ::fidl_next::fuchsia::HandleEncoder,
8486 &'a T0: ::fidl_next::Encode<
8487 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
8488 ___E,
8489 >,
8490 {
8491 #[inline]
8492 fn encode(
8493 self,
8494 encoder_: &mut ___E,
8495 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
8496 _: (),
8497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8498 ::fidl_next::munge! {
8499 let crate::wire::RealmGetResolvedInfoResponse {
8500 resolved_info,
8501
8502 } = out_;
8503 }
8504
8505 ::fidl_next::Encode::encode(&self.resolved_info, encoder_, resolved_info, ())?;
8506
8507 Ok(())
8508 }
8509 }
8510
8511 pub struct StorageAdminListStorageInRealmRequest<T0, T1> {
8513 pub relative_moniker: T0,
8514
8515 pub iterator: T1,
8516 }
8517
8518 unsafe impl<___E, T0, T1>
8519 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
8520 for StorageAdminListStorageInRealmRequest<T0, T1>
8521 where
8522 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8523 ___E: ::fidl_next::Encoder,
8524 ___E: ::fidl_next::fuchsia::HandleEncoder,
8525 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8526 T1: ::fidl_next::Encode<
8527 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
8528 ___E,
8529 >,
8530 {
8531 #[inline]
8532 fn encode(
8533 self,
8534 encoder_: &mut ___E,
8535 out_: &mut ::core::mem::MaybeUninit<
8536 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
8537 >,
8538 _: (),
8539 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8540 ::fidl_next::munge! {
8541 let crate::wire::StorageAdminListStorageInRealmRequest {
8542 relative_moniker,
8543 iterator,
8544
8545 } = out_;
8546 }
8547
8548 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
8549
8550 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
8551
8552 Ok(())
8553 }
8554 }
8555
8556 unsafe impl<'a, ___E, T0, T1>
8557 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
8558 for &'a StorageAdminListStorageInRealmRequest<T0, T1>
8559 where
8560 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8561 ___E: ::fidl_next::Encoder,
8562 ___E: ::fidl_next::fuchsia::HandleEncoder,
8563 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8564 &'a T1: ::fidl_next::Encode<
8565 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
8566 ___E,
8567 >,
8568 {
8569 #[inline]
8570 fn encode(
8571 self,
8572 encoder_: &mut ___E,
8573 out_: &mut ::core::mem::MaybeUninit<
8574 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
8575 >,
8576 _: (),
8577 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8578 ::fidl_next::munge! {
8579 let crate::wire::StorageAdminListStorageInRealmRequest {
8580 relative_moniker,
8581 iterator,
8582
8583 } = out_;
8584 }
8585
8586 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
8587
8588 ::fidl_next::Encode::encode(&self.iterator, encoder_, iterator, ())?;
8589
8590 Ok(())
8591 }
8592 }
8593
8594 pub struct StorageAdminOpenStorageRequest<T0, T1> {
8596 pub relative_moniker: T0,
8597
8598 pub object: T1,
8599 }
8600
8601 unsafe impl<___E, T0, T1>
8602 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
8603 for StorageAdminOpenStorageRequest<T0, T1>
8604 where
8605 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8606 ___E: ::fidl_next::Encoder,
8607 ___E: ::fidl_next::fuchsia::HandleEncoder,
8608 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8609 T1: ::fidl_next::Encode<
8610 ::fidl_next::ServerEnd<
8611 ::fidl_next_fuchsia_io::Node,
8612 ::fidl_next::wire::fuchsia::Channel,
8613 >,
8614 ___E,
8615 >,
8616 {
8617 #[inline]
8618 fn encode(
8619 self,
8620 encoder_: &mut ___E,
8621 out_: &mut ::core::mem::MaybeUninit<
8622 crate::wire::StorageAdminOpenStorageRequest<'static>,
8623 >,
8624 _: (),
8625 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8626 ::fidl_next::munge! {
8627 let crate::wire::StorageAdminOpenStorageRequest {
8628 relative_moniker,
8629 object,
8630
8631 } = out_;
8632 }
8633
8634 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
8635
8636 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
8637
8638 Ok(())
8639 }
8640 }
8641
8642 unsafe impl<'a, ___E, T0, T1>
8643 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
8644 for &'a StorageAdminOpenStorageRequest<T0, T1>
8645 where
8646 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8647 ___E: ::fidl_next::Encoder,
8648 ___E: ::fidl_next::fuchsia::HandleEncoder,
8649 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8650 &'a T1: ::fidl_next::Encode<
8651 ::fidl_next::ServerEnd<
8652 ::fidl_next_fuchsia_io::Node,
8653 ::fidl_next::wire::fuchsia::Channel,
8654 >,
8655 ___E,
8656 >,
8657 {
8658 #[inline]
8659 fn encode(
8660 self,
8661 encoder_: &mut ___E,
8662 out_: &mut ::core::mem::MaybeUninit<
8663 crate::wire::StorageAdminOpenStorageRequest<'static>,
8664 >,
8665 _: (),
8666 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8667 ::fidl_next::munge! {
8668 let crate::wire::StorageAdminOpenStorageRequest {
8669 relative_moniker,
8670 object,
8671
8672 } = out_;
8673 }
8674
8675 ::fidl_next::Encode::encode(&self.relative_moniker, encoder_, relative_moniker, 4096)?;
8676
8677 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
8678
8679 Ok(())
8680 }
8681 }
8682
8683 pub struct StorageAdminOpenComponentStorageByIdRequest<T0, T1> {
8685 pub id: T0,
8686
8687 pub object: T1,
8688 }
8689
8690 unsafe impl<___E, T0, T1>
8691 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
8692 for StorageAdminOpenComponentStorageByIdRequest<T0, T1>
8693 where
8694 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8695 ___E: ::fidl_next::Encoder,
8696 ___E: ::fidl_next::fuchsia::HandleEncoder,
8697 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8698 T1: ::fidl_next::Encode<
8699 ::fidl_next::ServerEnd<
8700 ::fidl_next_fuchsia_io::Node,
8701 ::fidl_next::wire::fuchsia::Channel,
8702 >,
8703 ___E,
8704 >,
8705 {
8706 #[inline]
8707 fn encode(
8708 self,
8709 encoder_: &mut ___E,
8710 out_: &mut ::core::mem::MaybeUninit<
8711 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
8712 >,
8713 _: (),
8714 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8715 ::fidl_next::munge! {
8716 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
8717 id,
8718 object,
8719
8720 } = out_;
8721 }
8722
8723 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
8724
8725 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
8726
8727 Ok(())
8728 }
8729 }
8730
8731 unsafe impl<'a, ___E, T0, T1>
8732 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
8733 for &'a StorageAdminOpenComponentStorageByIdRequest<T0, T1>
8734 where
8735 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
8736 ___E: ::fidl_next::Encoder,
8737 ___E: ::fidl_next::fuchsia::HandleEncoder,
8738 &'a T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
8739 &'a T1: ::fidl_next::Encode<
8740 ::fidl_next::ServerEnd<
8741 ::fidl_next_fuchsia_io::Node,
8742 ::fidl_next::wire::fuchsia::Channel,
8743 >,
8744 ___E,
8745 >,
8746 {
8747 #[inline]
8748 fn encode(
8749 self,
8750 encoder_: &mut ___E,
8751 out_: &mut ::core::mem::MaybeUninit<
8752 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
8753 >,
8754 _: (),
8755 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
8756 ::fidl_next::munge! {
8757 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
8758 id,
8759 object,
8760
8761 } = out_;
8762 }
8763
8764 ::fidl_next::Encode::encode(&self.id, encoder_, id, 64)?;
8765
8766 ::fidl_next::Encode::encode(&self.object, encoder_, object, ())?;
8767
8768 Ok(())
8769 }
8770 }
8771}
8772
8773pub use self::natural::*;
8774
8775#[doc = " A protocol used to operate on a component.\n\n One may get access to a `Controller` when creating a component with the\n `Realm.CreateChild` method. You may also obtain a `Controller` for an\n existing child component with the `Realm.OpenController` method.\n"]
8777#[derive(PartialEq, Debug)]
8778pub struct Controller;
8779
8780#[cfg(target_os = "fuchsia")]
8781impl ::fidl_next::HasTransport for Controller {
8782 type Transport = ::fidl_next::fuchsia::zx::Channel;
8783}
8784
8785pub mod controller {
8786 pub mod prelude {
8787 pub use crate::{
8788 Controller, ControllerClientHandler, ControllerLocalClientHandler,
8789 ControllerLocalServerHandler, ControllerServerHandler, controller,
8790 };
8791
8792 pub use crate::natural::ControllerOpenExposedDirRequest;
8793
8794 pub use crate::natural::ControllerStartRequest;
8795
8796 pub use crate::natural::ControllerDestroyResponse;
8797
8798 pub use crate::natural::ControllerGetExposedDictionaryResponse;
8799
8800 pub use crate::natural::ControllerGetOutputDictionaryResponse;
8801
8802 pub use crate::natural::ControllerIsStartedResponse;
8803
8804 pub use crate::natural::ControllerOpenExposedDirResponse;
8805
8806 pub use crate::natural::ControllerStartResponse;
8807
8808 pub use crate::natural::Error;
8809 }
8810
8811 pub struct Start;
8812
8813 impl ::fidl_next::Method for Start {
8814 const ORDINAL: u64 = 7532130149195770565;
8815 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8816 ::fidl_next::protocol::Flexibility::Flexible;
8817
8818 type Protocol = crate::Controller;
8819
8820 type Request = crate::wire::ControllerStartRequest<'static>;
8821 }
8822
8823 impl ::fidl_next::TwoWayMethod for Start {
8824 type Response = ::fidl_next::wire::Result<
8825 'static,
8826 crate::wire::ControllerStartResponse,
8827 crate::wire::Error,
8828 >;
8829 }
8830
8831 impl<___R> ::fidl_next::Respond<___R> for Start {
8832 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
8833
8834 fn respond(response: ___R) -> Self::Output {
8835 ::core::result::Result::Ok(response)
8836 }
8837 }
8838
8839 impl<___R> ::fidl_next::RespondErr<___R> for Start {
8840 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8841
8842 fn respond_err(response: ___R) -> Self::Output {
8843 ::core::result::Result::Err(response)
8844 }
8845 }
8846
8847 pub struct IsStarted;
8848
8849 impl ::fidl_next::Method for IsStarted {
8850 const ORDINAL: u64 = 2402079833990398915;
8851 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8852 ::fidl_next::protocol::Flexibility::Flexible;
8853
8854 type Protocol = crate::Controller;
8855
8856 type Request = ::fidl_next::wire::EmptyMessageBody;
8857 }
8858
8859 impl ::fidl_next::TwoWayMethod for IsStarted {
8860 type Response = ::fidl_next::wire::Result<
8861 'static,
8862 crate::wire::ControllerIsStartedResponse,
8863 crate::wire::Error,
8864 >;
8865 }
8866
8867 impl<___R> ::fidl_next::Respond<___R> for IsStarted {
8868 type Output = ::core::result::Result<
8869 crate::generic::ControllerIsStartedResponse<___R>,
8870 ::fidl_next::never::Never,
8871 >;
8872
8873 fn respond(response: ___R) -> Self::Output {
8874 ::core::result::Result::Ok(crate::generic::ControllerIsStartedResponse {
8875 is_started: response,
8876 })
8877 }
8878 }
8879
8880 impl<___R> ::fidl_next::RespondErr<___R> for IsStarted {
8881 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8882
8883 fn respond_err(response: ___R) -> Self::Output {
8884 ::core::result::Result::Err(response)
8885 }
8886 }
8887
8888 pub struct OpenExposedDir;
8889
8890 impl ::fidl_next::Method for OpenExposedDir {
8891 const ORDINAL: u64 = 2683208291886099860;
8892 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8893 ::fidl_next::protocol::Flexibility::Strict;
8894
8895 type Protocol = crate::Controller;
8896
8897 type Request = crate::wire::ControllerOpenExposedDirRequest;
8898 }
8899
8900 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
8901 type Response = ::fidl_next::wire::Result<
8902 'static,
8903 crate::wire::ControllerOpenExposedDirResponse,
8904 crate::wire::Error,
8905 >;
8906 }
8907
8908 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
8909 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
8910
8911 fn respond(response: ___R) -> Self::Output {
8912 ::core::result::Result::Ok(response)
8913 }
8914 }
8915
8916 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
8917 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8918
8919 fn respond_err(response: ___R) -> Self::Output {
8920 ::core::result::Result::Err(response)
8921 }
8922 }
8923
8924 pub struct GetExposedDictionary;
8925
8926 impl ::fidl_next::Method for GetExposedDictionary {
8927 const ORDINAL: u64 = 9099583788120940443;
8928 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8929 ::fidl_next::protocol::Flexibility::Flexible;
8930
8931 type Protocol = crate::Controller;
8932
8933 type Request = ::fidl_next::wire::EmptyMessageBody;
8934 }
8935
8936 impl ::fidl_next::TwoWayMethod for GetExposedDictionary {
8937 type Response = ::fidl_next::wire::Result<
8938 'static,
8939 crate::wire::ControllerGetExposedDictionaryResponse,
8940 crate::wire::Error,
8941 >;
8942 }
8943
8944 impl<___R> ::fidl_next::Respond<___R> for GetExposedDictionary {
8945 type Output = ::core::result::Result<
8946 crate::generic::ControllerGetExposedDictionaryResponse<___R>,
8947 ::fidl_next::never::Never,
8948 >;
8949
8950 fn respond(response: ___R) -> Self::Output {
8951 ::core::result::Result::Ok(crate::generic::ControllerGetExposedDictionaryResponse {
8952 dictionary: response,
8953 })
8954 }
8955 }
8956
8957 impl<___R> ::fidl_next::RespondErr<___R> for GetExposedDictionary {
8958 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8959
8960 fn respond_err(response: ___R) -> Self::Output {
8961 ::core::result::Result::Err(response)
8962 }
8963 }
8964
8965 pub struct GetOutputDictionary;
8966
8967 impl ::fidl_next::Method for GetOutputDictionary {
8968 const ORDINAL: u64 = 4182795765624263201;
8969 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8970 ::fidl_next::protocol::Flexibility::Flexible;
8971
8972 type Protocol = crate::Controller;
8973
8974 type Request = ::fidl_next::wire::EmptyMessageBody;
8975 }
8976
8977 impl ::fidl_next::TwoWayMethod for GetOutputDictionary {
8978 type Response = ::fidl_next::wire::Result<
8979 'static,
8980 crate::wire::ControllerGetOutputDictionaryResponse,
8981 crate::wire::Error,
8982 >;
8983 }
8984
8985 impl<___R> ::fidl_next::Respond<___R> for GetOutputDictionary {
8986 type Output = ::core::result::Result<
8987 crate::generic::ControllerGetOutputDictionaryResponse<___R>,
8988 ::fidl_next::never::Never,
8989 >;
8990
8991 fn respond(response: ___R) -> Self::Output {
8992 ::core::result::Result::Ok(crate::generic::ControllerGetOutputDictionaryResponse {
8993 dictionary: response,
8994 })
8995 }
8996 }
8997
8998 impl<___R> ::fidl_next::RespondErr<___R> for GetOutputDictionary {
8999 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9000
9001 fn respond_err(response: ___R) -> Self::Output {
9002 ::core::result::Result::Err(response)
9003 }
9004 }
9005
9006 pub struct Destroy;
9007
9008 impl ::fidl_next::Method for Destroy {
9009 const ORDINAL: u64 = 8381937394141370177;
9010 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9011 ::fidl_next::protocol::Flexibility::Flexible;
9012
9013 type Protocol = crate::Controller;
9014
9015 type Request = ::fidl_next::wire::EmptyMessageBody;
9016 }
9017
9018 impl ::fidl_next::TwoWayMethod for Destroy {
9019 type Response = ::fidl_next::wire::Result<
9020 'static,
9021 crate::wire::ControllerDestroyResponse,
9022 crate::wire::Error,
9023 >;
9024 }
9025
9026 impl<___R> ::fidl_next::Respond<___R> for Destroy {
9027 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
9028
9029 fn respond(response: ___R) -> Self::Output {
9030 ::core::result::Result::Ok(response)
9031 }
9032 }
9033
9034 impl<___R> ::fidl_next::RespondErr<___R> for Destroy {
9035 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9036
9037 fn respond_err(response: ___R) -> Self::Output {
9038 ::core::result::Result::Err(response)
9039 }
9040 }
9041
9042 mod ___detail {
9043 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Controller
9044 where
9045 ___T: ::fidl_next::Transport,
9046 {
9047 type Client = ControllerClient<___T>;
9048 type Server = ControllerServer<___T>;
9049 }
9050
9051 #[repr(transparent)]
9053 pub struct ControllerClient<___T: ::fidl_next::Transport> {
9054 #[allow(dead_code)]
9055 client: ::fidl_next::protocol::Client<___T>,
9056 }
9057
9058 impl<___T> ControllerClient<___T>
9059 where
9060 ___T: ::fidl_next::Transport,
9061 {
9062 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
9063 pub fn start(
9064 &self,
9065
9066 args: impl ::fidl_next::Encode<
9067 crate::wire::StartChildArgs<'static>,
9068 <___T as ::fidl_next::Transport>::SendBuffer,
9069 >,
9070
9071 execution_controller: impl ::fidl_next::Encode<
9072 ::fidl_next::ServerEnd<
9073 crate::ExecutionController,
9074 ::fidl_next::wire::fuchsia::Channel,
9075 >,
9076 <___T as ::fidl_next::Transport>::SendBuffer,
9077 >,
9078 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
9079 where
9080 <___T as ::fidl_next::Transport>::SendBuffer:
9081 ::fidl_next::encoder::InternalHandleEncoder,
9082 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9083 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9084 {
9085 self.start_with(crate::generic::ControllerStartRequest {
9086 args,
9087
9088 execution_controller,
9089 })
9090 }
9091
9092 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
9093 pub fn start_with<___R>(
9094 &self,
9095 request: ___R,
9096 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
9097 where
9098 ___R: ::fidl_next::Encode<
9099 crate::wire::ControllerStartRequest<'static>,
9100 <___T as ::fidl_next::Transport>::SendBuffer,
9101 >,
9102 {
9103 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9104 7532130149195770565,
9105 <super::Start as ::fidl_next::Method>::FLEXIBILITY,
9106 request,
9107 ))
9108 }
9109
9110 #[doc = " Returns true if this instance is currently running.\n"]
9111 pub fn is_started(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsStarted, ___T> {
9112 ::fidl_next::TwoWayFuture::from_untyped(
9113 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9114 2402079833990398915,
9115 <super::IsStarted as ::fidl_next::Method>::FLEXIBILITY,
9116 (),
9117 ),
9118 )
9119 }
9120
9121 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
9122 pub fn open_exposed_dir(
9123 &self,
9124
9125 exposed_dir: impl ::fidl_next::Encode<
9126 ::fidl_next::ServerEnd<
9127 ::fidl_next_fuchsia_io::Directory,
9128 ::fidl_next::wire::fuchsia::Channel,
9129 >,
9130 <___T as ::fidl_next::Transport>::SendBuffer,
9131 >,
9132 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
9133 where
9134 <___T as ::fidl_next::Transport>::SendBuffer:
9135 ::fidl_next::encoder::InternalHandleEncoder,
9136 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9137 {
9138 self.open_exposed_dir_with(crate::generic::ControllerOpenExposedDirRequest {
9139 exposed_dir,
9140 })
9141 }
9142
9143 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
9144 pub fn open_exposed_dir_with<___R>(
9145 &self,
9146 request: ___R,
9147 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
9148 where
9149 ___R: ::fidl_next::Encode<
9150 crate::wire::ControllerOpenExposedDirRequest,
9151 <___T as ::fidl_next::Transport>::SendBuffer,
9152 >,
9153 {
9154 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9155 2683208291886099860,
9156 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
9157 request,
9158 ))
9159 }
9160
9161 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
9162 pub fn get_exposed_dictionary(
9163 &self,
9164 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExposedDictionary, ___T> {
9165 ::fidl_next::TwoWayFuture::from_untyped(
9166 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9167 9099583788120940443,
9168 <super::GetExposedDictionary as ::fidl_next::Method>::FLEXIBILITY,
9169 (),
9170 ),
9171 )
9172 }
9173
9174 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
9175 pub fn get_output_dictionary(
9176 &self,
9177 ) -> ::fidl_next::TwoWayFuture<'_, super::GetOutputDictionary, ___T> {
9178 ::fidl_next::TwoWayFuture::from_untyped(
9179 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9180 4182795765624263201,
9181 <super::GetOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
9182 (),
9183 ),
9184 )
9185 }
9186
9187 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
9188 pub fn destroy(&self) -> ::fidl_next::TwoWayFuture<'_, super::Destroy, ___T> {
9189 ::fidl_next::TwoWayFuture::from_untyped(
9190 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9191 8381937394141370177,
9192 <super::Destroy as ::fidl_next::Method>::FLEXIBILITY,
9193 (),
9194 ),
9195 )
9196 }
9197 }
9198
9199 #[repr(transparent)]
9201 pub struct ControllerServer<___T: ::fidl_next::Transport> {
9202 server: ::fidl_next::protocol::Server<___T>,
9203 }
9204
9205 impl<___T> ControllerServer<___T> where ___T: ::fidl_next::Transport {}
9206 }
9207}
9208
9209#[diagnostic::on_unimplemented(
9210 note = "If {Self} implements the non-local ControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9211)]
9212
9213pub trait ControllerLocalClientHandler<
9217 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9218 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9219>
9220{
9221 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9222 ::core::future::ready(())
9223 }
9224}
9225
9226impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Controller
9227where
9228 ___H: ControllerLocalClientHandler<___T>,
9229 ___T: ::fidl_next::Transport,
9230{
9231 async fn on_event(
9232 handler: &mut ___H,
9233 mut message: ::fidl_next::Message<___T>,
9234 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9235 match *message.header().ordinal {
9236 ordinal => {
9237 handler.on_unknown_interaction(ordinal).await;
9238 if ::core::matches!(
9239 message.header().flexibility(),
9240 ::fidl_next::protocol::Flexibility::Strict
9241 ) {
9242 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9243 } else {
9244 Ok(())
9245 }
9246 }
9247 }
9248 }
9249}
9250
9251#[diagnostic::on_unimplemented(
9252 note = "If {Self} implements the non-local ControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9253)]
9254
9255pub trait ControllerLocalServerHandler<
9259 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9260 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9261>
9262{
9263 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
9264 fn start(
9265 &mut self,
9266
9267 request: ::fidl_next::Request<controller::Start, ___T>,
9268
9269 responder: ::fidl_next::Responder<controller::Start, ___T>,
9270 ) -> impl ::core::future::Future<Output = ()>;
9271
9272 #[doc = " Returns true if this instance is currently running.\n"]
9273 fn is_started(
9274 &mut self,
9275
9276 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
9277 ) -> impl ::core::future::Future<Output = ()>;
9278
9279 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
9280 fn open_exposed_dir(
9281 &mut self,
9282
9283 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
9284
9285 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
9286 ) -> impl ::core::future::Future<Output = ()>;
9287
9288 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
9289 fn get_exposed_dictionary(
9290 &mut self,
9291
9292 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
9293 ) -> impl ::core::future::Future<Output = ()>;
9294
9295 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
9296 fn get_output_dictionary(
9297 &mut self,
9298
9299 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
9300 ) -> impl ::core::future::Future<Output = ()>;
9301
9302 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
9303 fn destroy(
9304 &mut self,
9305
9306 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
9307 ) -> impl ::core::future::Future<Output = ()>;
9308
9309 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9310 ::core::future::ready(())
9311 }
9312}
9313
9314impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Controller
9315where
9316 ___H: ControllerLocalServerHandler<___T>,
9317 ___T: ::fidl_next::Transport,
9318 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
9319 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9320 Constraint = (),
9321 >,
9322 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
9323 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9324 Constraint = (),
9325 >,
9326{
9327 async fn on_one_way(
9328 handler: &mut ___H,
9329 mut message: ::fidl_next::Message<___T>,
9330 ) -> ::core::result::Result<
9331 (),
9332 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9333 > {
9334 match *message.header().ordinal {
9335 ordinal => {
9336 handler.on_unknown_interaction(ordinal).await;
9337 if ::core::matches!(
9338 message.header().flexibility(),
9339 ::fidl_next::protocol::Flexibility::Strict
9340 ) {
9341 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9342 } else {
9343 Ok(())
9344 }
9345 }
9346 }
9347 }
9348
9349 async fn on_two_way(
9350 handler: &mut ___H,
9351 mut message: ::fidl_next::Message<___T>,
9352 responder: ::fidl_next::protocol::Responder<___T>,
9353 ) -> ::core::result::Result<
9354 (),
9355 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9356 > {
9357 match *message.header().ordinal {
9358 7532130149195770565 => {
9359 let responder = ::fidl_next::Responder::from_untyped(responder);
9360
9361 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9362 Ok(decoded) => {
9363 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
9364 Ok(())
9365 }
9366 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9367 ordinal: 7532130149195770565,
9368 error,
9369 }),
9370 }
9371 }
9372
9373 2402079833990398915 => {
9374 let responder = ::fidl_next::Responder::from_untyped(responder);
9375
9376 handler.is_started(responder).await;
9377 Ok(())
9378 }
9379
9380 2683208291886099860 => {
9381 let responder = ::fidl_next::Responder::from_untyped(responder);
9382
9383 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9384 Ok(decoded) => {
9385 handler
9386 .open_exposed_dir(
9387 ::fidl_next::Request::from_decoded(decoded),
9388 responder,
9389 )
9390 .await;
9391 Ok(())
9392 }
9393 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9394 ordinal: 2683208291886099860,
9395 error,
9396 }),
9397 }
9398 }
9399
9400 9099583788120940443 => {
9401 let responder = ::fidl_next::Responder::from_untyped(responder);
9402
9403 handler.get_exposed_dictionary(responder).await;
9404 Ok(())
9405 }
9406
9407 4182795765624263201 => {
9408 let responder = ::fidl_next::Responder::from_untyped(responder);
9409
9410 handler.get_output_dictionary(responder).await;
9411 Ok(())
9412 }
9413
9414 8381937394141370177 => {
9415 let responder = ::fidl_next::Responder::from_untyped(responder);
9416
9417 handler.destroy(responder).await;
9418 Ok(())
9419 }
9420
9421 ordinal => {
9422 handler.on_unknown_interaction(ordinal).await;
9423 if ::core::matches!(
9424 message.header().flexibility(),
9425 ::fidl_next::protocol::Flexibility::Strict
9426 ) {
9427 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9428 } else {
9429 responder
9430 .respond_framework_error(
9431 ordinal,
9432 ::fidl_next::FrameworkError::UnknownMethod,
9433 )
9434 .expect("encoding a framework error should never fail")
9435 .await?;
9436 Ok(())
9437 }
9438 }
9439 }
9440 }
9441}
9442
9443pub trait ControllerClientHandler<
9447 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9448 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9449>
9450{
9451 fn on_unknown_interaction(
9452 &mut self,
9453 ordinal: u64,
9454 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9455 ::core::future::ready(())
9456 }
9457}
9458
9459impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Controller
9460where
9461 ___H: ControllerClientHandler<___T> + ::core::marker::Send,
9462 ___T: ::fidl_next::Transport,
9463{
9464 async fn on_event(
9465 handler: &mut ___H,
9466 mut message: ::fidl_next::Message<___T>,
9467 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9468 match *message.header().ordinal {
9469 ordinal => {
9470 handler.on_unknown_interaction(ordinal).await;
9471 if ::core::matches!(
9472 message.header().flexibility(),
9473 ::fidl_next::protocol::Flexibility::Strict
9474 ) {
9475 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9476 } else {
9477 Ok(())
9478 }
9479 }
9480 }
9481 }
9482}
9483
9484pub trait ControllerServerHandler<
9488 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9489 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9490>
9491{
9492 #[doc = " Start the component, optionally providing additional handles to be given\n to the component. Returns INSTANCE_ALREADY_RUNNING if the instance is\n currently running.\n"]
9493 fn start(
9494 &mut self,
9495
9496 request: ::fidl_next::Request<controller::Start, ___T>,
9497
9498 responder: ::fidl_next::Responder<controller::Start, ___T>,
9499 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9500
9501 #[doc = " Returns true if this instance is currently running.\n"]
9502 fn is_started(
9503 &mut self,
9504
9505 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
9506 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9507
9508 #[doc = " Opens the exposed directory of the controlled component, through which\n capabilities the component exposed via `ComponentDecl.exposes` are\n available, on success.\n\n Binding to the exposed directory requires that the component be\n resolved, but it will not be started until/unless some capability is\n requested that requires it to be.\n\n If this component is destroyed, any outstanding connections to\n `exposed_dir` will be closed.\n\n Errors:\n - `INSTANCE_CANNOT_RESOLVE`: This component failed to resolve.\n"]
9509 fn open_exposed_dir(
9510 &mut self,
9511
9512 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
9513
9514 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
9515 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9516
9517 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
9518 fn get_exposed_dictionary(
9519 &mut self,
9520
9521 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
9522 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9523
9524 #[doc = " Returns a reference to the component\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
9525 fn get_output_dictionary(
9526 &mut self,
9527
9528 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
9529 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9530
9531 #[doc = " Destroys this component. When this method returns, the component is\n either destroyed or in the case of an error no destruction happened.\n\n Errors:\n\n - `ACCESS_DENIED`: Destruction of this component is not allowed.\n Currently, this can happen if the component is a static child of its\n parent.\n - `INTERNAL`: Something prevented destruction from succeeding -- component\n manager\'s logs will contain more detail.\n"]
9532 fn destroy(
9533 &mut self,
9534
9535 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
9536 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9537
9538 fn on_unknown_interaction(
9539 &mut self,
9540 ordinal: u64,
9541 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9542 ::core::future::ready(())
9543 }
9544}
9545
9546impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Controller
9547where
9548 ___H: ControllerServerHandler<___T> + ::core::marker::Send,
9549 ___T: ::fidl_next::Transport,
9550 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
9551 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9552 Constraint = (),
9553 >,
9554 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
9555 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9556 Constraint = (),
9557 >,
9558{
9559 async fn on_one_way(
9560 handler: &mut ___H,
9561 mut message: ::fidl_next::Message<___T>,
9562 ) -> ::core::result::Result<
9563 (),
9564 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9565 > {
9566 match *message.header().ordinal {
9567 ordinal => {
9568 handler.on_unknown_interaction(ordinal).await;
9569 if ::core::matches!(
9570 message.header().flexibility(),
9571 ::fidl_next::protocol::Flexibility::Strict
9572 ) {
9573 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9574 } else {
9575 Ok(())
9576 }
9577 }
9578 }
9579 }
9580
9581 async fn on_two_way(
9582 handler: &mut ___H,
9583 mut message: ::fidl_next::Message<___T>,
9584 responder: ::fidl_next::protocol::Responder<___T>,
9585 ) -> ::core::result::Result<
9586 (),
9587 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9588 > {
9589 match *message.header().ordinal {
9590 7532130149195770565 => {
9591 let responder = ::fidl_next::Responder::from_untyped(responder);
9592
9593 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9594 Ok(decoded) => {
9595 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
9596 Ok(())
9597 }
9598 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9599 ordinal: 7532130149195770565,
9600 error,
9601 }),
9602 }
9603 }
9604
9605 2402079833990398915 => {
9606 let responder = ::fidl_next::Responder::from_untyped(responder);
9607
9608 handler.is_started(responder).await;
9609 Ok(())
9610 }
9611
9612 2683208291886099860 => {
9613 let responder = ::fidl_next::Responder::from_untyped(responder);
9614
9615 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9616 Ok(decoded) => {
9617 handler
9618 .open_exposed_dir(
9619 ::fidl_next::Request::from_decoded(decoded),
9620 responder,
9621 )
9622 .await;
9623 Ok(())
9624 }
9625 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9626 ordinal: 2683208291886099860,
9627 error,
9628 }),
9629 }
9630 }
9631
9632 9099583788120940443 => {
9633 let responder = ::fidl_next::Responder::from_untyped(responder);
9634
9635 handler.get_exposed_dictionary(responder).await;
9636 Ok(())
9637 }
9638
9639 4182795765624263201 => {
9640 let responder = ::fidl_next::Responder::from_untyped(responder);
9641
9642 handler.get_output_dictionary(responder).await;
9643 Ok(())
9644 }
9645
9646 8381937394141370177 => {
9647 let responder = ::fidl_next::Responder::from_untyped(responder);
9648
9649 handler.destroy(responder).await;
9650 Ok(())
9651 }
9652
9653 ordinal => {
9654 handler.on_unknown_interaction(ordinal).await;
9655 if ::core::matches!(
9656 message.header().flexibility(),
9657 ::fidl_next::protocol::Flexibility::Strict
9658 ) {
9659 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9660 } else {
9661 responder
9662 .respond_framework_error(
9663 ordinal,
9664 ::fidl_next::FrameworkError::UnknownMethod,
9665 )
9666 .expect("encoding a framework error should never fail")
9667 .await?;
9668 Ok(())
9669 }
9670 }
9671 }
9672 }
9673}
9674
9675impl<___T> ControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
9676where
9677 ___T: ::fidl_next::Transport,
9678{
9679 async fn on_unknown_interaction(&mut self, _: u64) {}
9680}
9681
9682impl<___H, ___T> ControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
9683where
9684 ___H: ControllerClientHandler<___T>,
9685 ___T: ::fidl_next::Transport,
9686{
9687 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9688 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9689 }
9690}
9691
9692impl<___H, ___T> ControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
9693where
9694 ___H: ControllerServerHandler<___T>,
9695 ___T: ::fidl_next::Transport,
9696{
9697 async fn start(
9698 &mut self,
9699
9700 request: ::fidl_next::Request<controller::Start, ___T>,
9701
9702 responder: ::fidl_next::Responder<controller::Start, ___T>,
9703 ) {
9704 ___H::start(&mut self.0, request, responder).await
9705 }
9706
9707 async fn is_started(&mut self, responder: ::fidl_next::Responder<controller::IsStarted, ___T>) {
9708 ___H::is_started(&mut self.0, responder).await
9709 }
9710
9711 async fn open_exposed_dir(
9712 &mut self,
9713
9714 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
9715
9716 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
9717 ) {
9718 ___H::open_exposed_dir(&mut self.0, request, responder).await
9719 }
9720
9721 async fn get_exposed_dictionary(
9722 &mut self,
9723
9724 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
9725 ) {
9726 ___H::get_exposed_dictionary(&mut self.0, responder).await
9727 }
9728
9729 async fn get_output_dictionary(
9730 &mut self,
9731
9732 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
9733 ) {
9734 ___H::get_output_dictionary(&mut self.0, responder).await
9735 }
9736
9737 async fn destroy(&mut self, responder: ::fidl_next::Responder<controller::Destroy, ___T>) {
9738 ___H::destroy(&mut self.0, responder).await
9739 }
9740
9741 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9742 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9743 }
9744}
9745
9746#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
9748#[derive(PartialEq, Debug)]
9749pub struct EventStream;
9750
9751impl ::fidl_next::Discoverable for EventStream {
9752 const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
9753}
9754
9755#[cfg(target_os = "fuchsia")]
9756impl ::fidl_next::HasTransport for EventStream {
9757 type Transport = ::fidl_next::fuchsia::zx::Channel;
9758}
9759
9760pub mod event_stream {
9761 pub mod prelude {
9762 pub use crate::{
9763 EventStream, EventStreamClientHandler, EventStreamLocalClientHandler,
9764 EventStreamLocalServerHandler, EventStreamServerHandler, event_stream,
9765 };
9766
9767 pub use crate::natural::EventStreamGetNextResponse;
9768 }
9769
9770 pub struct GetNext;
9771
9772 impl ::fidl_next::Method for GetNext {
9773 const ORDINAL: u64 = 4549982840421936006;
9774 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9775 ::fidl_next::protocol::Flexibility::Strict;
9776
9777 type Protocol = crate::EventStream;
9778
9779 type Request = ::fidl_next::wire::EmptyMessageBody;
9780 }
9781
9782 impl ::fidl_next::TwoWayMethod for GetNext {
9783 type Response = ::fidl_next::wire::Strict<crate::wire::EventStreamGetNextResponse<'static>>;
9784 }
9785
9786 impl<___R> ::fidl_next::Respond<___R> for GetNext {
9787 type Output = ::fidl_next::Strict<crate::generic::EventStreamGetNextResponse<___R>>;
9788
9789 fn respond(response: ___R) -> Self::Output {
9790 ::fidl_next::Strict(crate::generic::EventStreamGetNextResponse { events: response })
9791 }
9792 }
9793
9794 pub struct WaitForReady;
9795
9796 impl ::fidl_next::Method for WaitForReady {
9797 const ORDINAL: u64 = 3545212058508387970;
9798 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9799 ::fidl_next::protocol::Flexibility::Strict;
9800
9801 type Protocol = crate::EventStream;
9802
9803 type Request = ::fidl_next::wire::EmptyMessageBody;
9804 }
9805
9806 impl ::fidl_next::TwoWayMethod for WaitForReady {
9807 type Response = ::fidl_next::wire::Strict<::fidl_next::wire::EmptyMessageBody>;
9808 }
9809
9810 impl<___R> ::fidl_next::Respond<___R> for WaitForReady {
9811 type Output = ::fidl_next::Strict<___R>;
9812
9813 fn respond(response: ___R) -> Self::Output {
9814 ::fidl_next::Strict(response)
9815 }
9816 }
9817
9818 mod ___detail {
9819 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::EventStream
9820 where
9821 ___T: ::fidl_next::Transport,
9822 {
9823 type Client = EventStreamClient<___T>;
9824 type Server = EventStreamServer<___T>;
9825 }
9826
9827 #[repr(transparent)]
9829 pub struct EventStreamClient<___T: ::fidl_next::Transport> {
9830 #[allow(dead_code)]
9831 client: ::fidl_next::protocol::Client<___T>,
9832 }
9833
9834 impl<___T> EventStreamClient<___T>
9835 where
9836 ___T: ::fidl_next::Transport,
9837 {
9838 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
9839 ::fidl_next::TwoWayFuture::from_untyped(
9840 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9841 4549982840421936006,
9842 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
9843 (),
9844 ),
9845 )
9846 }
9847
9848 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
9849 pub fn wait_for_ready(
9850 &self,
9851 ) -> ::fidl_next::TwoWayFuture<'_, super::WaitForReady, ___T> {
9852 ::fidl_next::TwoWayFuture::from_untyped(
9853 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9854 3545212058508387970,
9855 <super::WaitForReady as ::fidl_next::Method>::FLEXIBILITY,
9856 (),
9857 ),
9858 )
9859 }
9860 }
9861
9862 #[repr(transparent)]
9864 pub struct EventStreamServer<___T: ::fidl_next::Transport> {
9865 server: ::fidl_next::protocol::Server<___T>,
9866 }
9867
9868 impl<___T> EventStreamServer<___T> where ___T: ::fidl_next::Transport {}
9869 }
9870}
9871
9872#[diagnostic::on_unimplemented(
9873 note = "If {Self} implements the non-local EventStreamClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9874)]
9875
9876pub trait EventStreamLocalClientHandler<
9880 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9881 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9882>
9883{
9884}
9885
9886impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for EventStream
9887where
9888 ___H: EventStreamLocalClientHandler<___T>,
9889 ___T: ::fidl_next::Transport,
9890{
9891 async fn on_event(
9892 handler: &mut ___H,
9893 mut message: ::fidl_next::Message<___T>,
9894 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9895 match *message.header().ordinal {
9896 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9897 }
9898 }
9899}
9900
9901#[diagnostic::on_unimplemented(
9902 note = "If {Self} implements the non-local EventStreamServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9903)]
9904
9905pub trait EventStreamLocalServerHandler<
9909 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9910 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9911>
9912{
9913 fn get_next(
9914 &mut self,
9915
9916 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
9917 ) -> impl ::core::future::Future<Output = ()>;
9918
9919 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
9920 fn wait_for_ready(
9921 &mut self,
9922
9923 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9924 ) -> impl ::core::future::Future<Output = ()>;
9925}
9926
9927impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for EventStream
9928where
9929 ___H: EventStreamLocalServerHandler<___T>,
9930 ___T: ::fidl_next::Transport,
9931{
9932 async fn on_one_way(
9933 handler: &mut ___H,
9934 mut message: ::fidl_next::Message<___T>,
9935 ) -> ::core::result::Result<
9936 (),
9937 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9938 > {
9939 match *message.header().ordinal {
9940 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9941 }
9942 }
9943
9944 async fn on_two_way(
9945 handler: &mut ___H,
9946 mut message: ::fidl_next::Message<___T>,
9947 responder: ::fidl_next::protocol::Responder<___T>,
9948 ) -> ::core::result::Result<
9949 (),
9950 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9951 > {
9952 match *message.header().ordinal {
9953 4549982840421936006 => {
9954 let responder = ::fidl_next::Responder::from_untyped(responder);
9955
9956 handler.get_next(responder).await;
9957 Ok(())
9958 }
9959
9960 3545212058508387970 => {
9961 let responder = ::fidl_next::Responder::from_untyped(responder);
9962
9963 handler.wait_for_ready(responder).await;
9964 Ok(())
9965 }
9966
9967 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9968 }
9969 }
9970}
9971
9972pub trait EventStreamClientHandler<
9976 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9977 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9978>
9979{
9980}
9981
9982impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for EventStream
9983where
9984 ___H: EventStreamClientHandler<___T> + ::core::marker::Send,
9985 ___T: ::fidl_next::Transport,
9986{
9987 async fn on_event(
9988 handler: &mut ___H,
9989 mut message: ::fidl_next::Message<___T>,
9990 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9991 match *message.header().ordinal {
9992 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9993 }
9994 }
9995}
9996
9997pub trait EventStreamServerHandler<
10001 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10002 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10003>
10004{
10005 fn get_next(
10006 &mut self,
10007
10008 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
10009 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10010
10011 #[doc = " Returns immediately. Used to indicate that the FIDL connection\n completed. This is needed for non-static streams to verify\n that subscribe has completed before components are started.\n"]
10012 fn wait_for_ready(
10013 &mut self,
10014
10015 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
10016 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10017}
10018
10019impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for EventStream
10020where
10021 ___H: EventStreamServerHandler<___T> + ::core::marker::Send,
10022 ___T: ::fidl_next::Transport,
10023{
10024 async fn on_one_way(
10025 handler: &mut ___H,
10026 mut message: ::fidl_next::Message<___T>,
10027 ) -> ::core::result::Result<
10028 (),
10029 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10030 > {
10031 match *message.header().ordinal {
10032 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10033 }
10034 }
10035
10036 async fn on_two_way(
10037 handler: &mut ___H,
10038 mut message: ::fidl_next::Message<___T>,
10039 responder: ::fidl_next::protocol::Responder<___T>,
10040 ) -> ::core::result::Result<
10041 (),
10042 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10043 > {
10044 match *message.header().ordinal {
10045 4549982840421936006 => {
10046 let responder = ::fidl_next::Responder::from_untyped(responder);
10047
10048 handler.get_next(responder).await;
10049 Ok(())
10050 }
10051
10052 3545212058508387970 => {
10053 let responder = ::fidl_next::Responder::from_untyped(responder);
10054
10055 handler.wait_for_ready(responder).await;
10056 Ok(())
10057 }
10058
10059 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10060 }
10061 }
10062}
10063
10064impl<___T> EventStreamClientHandler<___T> for ::fidl_next::IgnoreEvents where
10065 ___T: ::fidl_next::Transport
10066{
10067}
10068
10069impl<___H, ___T> EventStreamLocalClientHandler<___T> for ::fidl_next::Local<___H>
10070where
10071 ___H: EventStreamClientHandler<___T>,
10072 ___T: ::fidl_next::Transport,
10073{
10074}
10075
10076impl<___H, ___T> EventStreamLocalServerHandler<___T> for ::fidl_next::Local<___H>
10077where
10078 ___H: EventStreamServerHandler<___T>,
10079 ___T: ::fidl_next::Transport,
10080{
10081 async fn get_next(&mut self, responder: ::fidl_next::Responder<event_stream::GetNext, ___T>) {
10082 ___H::get_next(&mut self.0, responder).await
10083 }
10084
10085 async fn wait_for_ready(
10086 &mut self,
10087
10088 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
10089 ) {
10090 ___H::wait_for_ready(&mut self.0, responder).await
10091 }
10092}
10093
10094#[doc = " A protocol used by a component instance to obtain information about\n components in its own realm.\n\n This protocol only supports getting the moniker at the moment but could\n expand to other privileged information such as the URL of a component.\n\n The component framework provides this capability to components that use\n `fuchsia.component.Introspector` from framework.\n"]
10096#[derive(PartialEq, Debug)]
10097pub struct Introspector;
10098
10099impl ::fidl_next::Discoverable for Introspector {
10100 const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
10101}
10102
10103#[cfg(target_os = "fuchsia")]
10104impl ::fidl_next::HasTransport for Introspector {
10105 type Transport = ::fidl_next::fuchsia::zx::Channel;
10106}
10107
10108pub mod introspector {
10109 pub mod prelude {
10110 pub use crate::{
10111 Introspector, IntrospectorClientHandler, IntrospectorLocalClientHandler,
10112 IntrospectorLocalServerHandler, IntrospectorServerHandler, introspector,
10113 };
10114
10115 pub use crate::natural::Error;
10116
10117 pub use crate::natural::IntrospectorGetMonikerRequest;
10118
10119 pub use crate::natural::IntrospectorGetMonikerResponse;
10120 }
10121
10122 pub struct GetMoniker;
10123
10124 impl ::fidl_next::Method for GetMoniker {
10125 const ORDINAL: u64 = 214344082539672664;
10126 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10127 ::fidl_next::protocol::Flexibility::Flexible;
10128
10129 type Protocol = crate::Introspector;
10130
10131 type Request = crate::wire::IntrospectorGetMonikerRequest;
10132 }
10133
10134 impl ::fidl_next::TwoWayMethod for GetMoniker {
10135 type Response = ::fidl_next::wire::Result<
10136 'static,
10137 crate::wire::IntrospectorGetMonikerResponse<'static>,
10138 crate::wire::Error,
10139 >;
10140 }
10141
10142 impl<___R> ::fidl_next::Respond<___R> for GetMoniker {
10143 type Output = ::core::result::Result<
10144 crate::generic::IntrospectorGetMonikerResponse<___R>,
10145 ::fidl_next::never::Never,
10146 >;
10147
10148 fn respond(response: ___R) -> Self::Output {
10149 ::core::result::Result::Ok(crate::generic::IntrospectorGetMonikerResponse {
10150 moniker: response,
10151 })
10152 }
10153 }
10154
10155 impl<___R> ::fidl_next::RespondErr<___R> for GetMoniker {
10156 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10157
10158 fn respond_err(response: ___R) -> Self::Output {
10159 ::core::result::Result::Err(response)
10160 }
10161 }
10162
10163 mod ___detail {
10164 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Introspector
10165 where
10166 ___T: ::fidl_next::Transport,
10167 {
10168 type Client = IntrospectorClient<___T>;
10169 type Server = IntrospectorServer<___T>;
10170 }
10171
10172 #[repr(transparent)]
10174 pub struct IntrospectorClient<___T: ::fidl_next::Transport> {
10175 #[allow(dead_code)]
10176 client: ::fidl_next::protocol::Client<___T>,
10177 }
10178
10179 impl<___T> IntrospectorClient<___T>
10180 where
10181 ___T: ::fidl_next::Transport,
10182 {
10183 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
10184 pub fn get_moniker(
10185 &self,
10186
10187 component_instance: impl ::fidl_next::Encode<
10188 ::fidl_next::wire::fuchsia::Event,
10189 <___T as ::fidl_next::Transport>::SendBuffer,
10190 >,
10191 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
10192 where
10193 <___T as ::fidl_next::Transport>::SendBuffer:
10194 ::fidl_next::encoder::InternalHandleEncoder,
10195 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10196 {
10197 self.get_moniker_with(crate::generic::IntrospectorGetMonikerRequest {
10198 component_instance,
10199 })
10200 }
10201
10202 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
10203 pub fn get_moniker_with<___R>(
10204 &self,
10205 request: ___R,
10206 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
10207 where
10208 ___R: ::fidl_next::Encode<
10209 crate::wire::IntrospectorGetMonikerRequest,
10210 <___T as ::fidl_next::Transport>::SendBuffer,
10211 >,
10212 {
10213 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10214 214344082539672664,
10215 <super::GetMoniker as ::fidl_next::Method>::FLEXIBILITY,
10216 request,
10217 ))
10218 }
10219 }
10220
10221 #[repr(transparent)]
10223 pub struct IntrospectorServer<___T: ::fidl_next::Transport> {
10224 server: ::fidl_next::protocol::Server<___T>,
10225 }
10226
10227 impl<___T> IntrospectorServer<___T> where ___T: ::fidl_next::Transport {}
10228 }
10229}
10230
10231#[diagnostic::on_unimplemented(
10232 note = "If {Self} implements the non-local IntrospectorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10233)]
10234
10235pub trait IntrospectorLocalClientHandler<
10239 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10240 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10241>
10242{
10243 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10244 ::core::future::ready(())
10245 }
10246}
10247
10248impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Introspector
10249where
10250 ___H: IntrospectorLocalClientHandler<___T>,
10251 ___T: ::fidl_next::Transport,
10252{
10253 async fn on_event(
10254 handler: &mut ___H,
10255 mut message: ::fidl_next::Message<___T>,
10256 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10257 match *message.header().ordinal {
10258 ordinal => {
10259 handler.on_unknown_interaction(ordinal).await;
10260 if ::core::matches!(
10261 message.header().flexibility(),
10262 ::fidl_next::protocol::Flexibility::Strict
10263 ) {
10264 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10265 } else {
10266 Ok(())
10267 }
10268 }
10269 }
10270 }
10271}
10272
10273#[diagnostic::on_unimplemented(
10274 note = "If {Self} implements the non-local IntrospectorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
10275)]
10276
10277pub trait IntrospectorLocalServerHandler<
10281 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10282 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10283>
10284{
10285 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
10286 fn get_moniker(
10287 &mut self,
10288
10289 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
10290
10291 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
10292 ) -> impl ::core::future::Future<Output = ()>;
10293
10294 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10295 ::core::future::ready(())
10296 }
10297}
10298
10299impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Introspector
10300where
10301 ___H: IntrospectorLocalServerHandler<___T>,
10302 ___T: ::fidl_next::Transport,
10303 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
10304 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10305 Constraint = (),
10306 >,
10307{
10308 async fn on_one_way(
10309 handler: &mut ___H,
10310 mut message: ::fidl_next::Message<___T>,
10311 ) -> ::core::result::Result<
10312 (),
10313 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10314 > {
10315 match *message.header().ordinal {
10316 ordinal => {
10317 handler.on_unknown_interaction(ordinal).await;
10318 if ::core::matches!(
10319 message.header().flexibility(),
10320 ::fidl_next::protocol::Flexibility::Strict
10321 ) {
10322 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10323 } else {
10324 Ok(())
10325 }
10326 }
10327 }
10328 }
10329
10330 async fn on_two_way(
10331 handler: &mut ___H,
10332 mut message: ::fidl_next::Message<___T>,
10333 responder: ::fidl_next::protocol::Responder<___T>,
10334 ) -> ::core::result::Result<
10335 (),
10336 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10337 > {
10338 match *message.header().ordinal {
10339 214344082539672664 => {
10340 let responder = ::fidl_next::Responder::from_untyped(responder);
10341
10342 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10343 Ok(decoded) => {
10344 handler
10345 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
10346 .await;
10347 Ok(())
10348 }
10349 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10350 ordinal: 214344082539672664,
10351 error,
10352 }),
10353 }
10354 }
10355
10356 ordinal => {
10357 handler.on_unknown_interaction(ordinal).await;
10358 if ::core::matches!(
10359 message.header().flexibility(),
10360 ::fidl_next::protocol::Flexibility::Strict
10361 ) {
10362 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10363 } else {
10364 responder
10365 .respond_framework_error(
10366 ordinal,
10367 ::fidl_next::FrameworkError::UnknownMethod,
10368 )
10369 .expect("encoding a framework error should never fail")
10370 .await?;
10371 Ok(())
10372 }
10373 }
10374 }
10375 }
10376}
10377
10378pub trait IntrospectorClientHandler<
10382 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10383 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10384>
10385{
10386 fn on_unknown_interaction(
10387 &mut self,
10388 ordinal: u64,
10389 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10390 ::core::future::ready(())
10391 }
10392}
10393
10394impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Introspector
10395where
10396 ___H: IntrospectorClientHandler<___T> + ::core::marker::Send,
10397 ___T: ::fidl_next::Transport,
10398{
10399 async fn on_event(
10400 handler: &mut ___H,
10401 mut message: ::fidl_next::Message<___T>,
10402 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10403 match *message.header().ordinal {
10404 ordinal => {
10405 handler.on_unknown_interaction(ordinal).await;
10406 if ::core::matches!(
10407 message.header().flexibility(),
10408 ::fidl_next::protocol::Flexibility::Strict
10409 ) {
10410 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10411 } else {
10412 Ok(())
10413 }
10414 }
10415 }
10416 }
10417}
10418
10419pub trait IntrospectorServerHandler<
10423 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10424 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10425>
10426{
10427 #[doc = " Obtains the moniker relative to this realm of the component\n corresponding to the provided token. Runners may obtain the token via\n `fuchsia.component.runner/ComponentStartInfo.component_instance`.\n\n Returns `Error.INSTANCE_NOT_FOUND` if the token is invalid, or\n does not correspond to a component under this realm.\n"]
10428 fn get_moniker(
10429 &mut self,
10430
10431 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
10432
10433 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
10434 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10435
10436 fn on_unknown_interaction(
10437 &mut self,
10438 ordinal: u64,
10439 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10440 ::core::future::ready(())
10441 }
10442}
10443
10444impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Introspector
10445where
10446 ___H: IntrospectorServerHandler<___T> + ::core::marker::Send,
10447 ___T: ::fidl_next::Transport,
10448 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
10449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10450 Constraint = (),
10451 >,
10452{
10453 async fn on_one_way(
10454 handler: &mut ___H,
10455 mut message: ::fidl_next::Message<___T>,
10456 ) -> ::core::result::Result<
10457 (),
10458 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10459 > {
10460 match *message.header().ordinal {
10461 ordinal => {
10462 handler.on_unknown_interaction(ordinal).await;
10463 if ::core::matches!(
10464 message.header().flexibility(),
10465 ::fidl_next::protocol::Flexibility::Strict
10466 ) {
10467 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10468 } else {
10469 Ok(())
10470 }
10471 }
10472 }
10473 }
10474
10475 async fn on_two_way(
10476 handler: &mut ___H,
10477 mut message: ::fidl_next::Message<___T>,
10478 responder: ::fidl_next::protocol::Responder<___T>,
10479 ) -> ::core::result::Result<
10480 (),
10481 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10482 > {
10483 match *message.header().ordinal {
10484 214344082539672664 => {
10485 let responder = ::fidl_next::Responder::from_untyped(responder);
10486
10487 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10488 Ok(decoded) => {
10489 handler
10490 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
10491 .await;
10492 Ok(())
10493 }
10494 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10495 ordinal: 214344082539672664,
10496 error,
10497 }),
10498 }
10499 }
10500
10501 ordinal => {
10502 handler.on_unknown_interaction(ordinal).await;
10503 if ::core::matches!(
10504 message.header().flexibility(),
10505 ::fidl_next::protocol::Flexibility::Strict
10506 ) {
10507 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10508 } else {
10509 responder
10510 .respond_framework_error(
10511 ordinal,
10512 ::fidl_next::FrameworkError::UnknownMethod,
10513 )
10514 .expect("encoding a framework error should never fail")
10515 .await?;
10516 Ok(())
10517 }
10518 }
10519 }
10520 }
10521}
10522
10523impl<___T> IntrospectorClientHandler<___T> for ::fidl_next::IgnoreEvents
10524where
10525 ___T: ::fidl_next::Transport,
10526{
10527 async fn on_unknown_interaction(&mut self, _: u64) {}
10528}
10529
10530impl<___H, ___T> IntrospectorLocalClientHandler<___T> for ::fidl_next::Local<___H>
10531where
10532 ___H: IntrospectorClientHandler<___T>,
10533 ___T: ::fidl_next::Transport,
10534{
10535 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10536 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10537 }
10538}
10539
10540impl<___H, ___T> IntrospectorLocalServerHandler<___T> for ::fidl_next::Local<___H>
10541where
10542 ___H: IntrospectorServerHandler<___T>,
10543 ___T: ::fidl_next::Transport,
10544{
10545 async fn get_moniker(
10546 &mut self,
10547
10548 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
10549
10550 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
10551 ) {
10552 ___H::get_moniker(&mut self.0, request, responder).await
10553 }
10554
10555 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10556 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10557 }
10558}
10559
10560#[doc = " Protocol for performing namespace operations.\n"]
10562#[derive(PartialEq, Debug)]
10563pub struct Namespace;
10564
10565impl ::fidl_next::Discoverable for Namespace {
10566 const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
10567}
10568
10569#[cfg(target_os = "fuchsia")]
10570impl ::fidl_next::HasTransport for Namespace {
10571 type Transport = ::fidl_next::fuchsia::zx::Channel;
10572}
10573
10574pub mod namespace {
10575 pub mod prelude {
10576 pub use crate::{
10577 Namespace, NamespaceClientHandler, NamespaceLocalClientHandler,
10578 NamespaceLocalServerHandler, NamespaceServerHandler, namespace,
10579 };
10580
10581 pub use crate::natural::NamespaceCreate2Request;
10582
10583 pub use crate::natural::NamespaceCreateRequest;
10584
10585 pub use crate::natural::NamespaceError;
10586
10587 pub use crate::natural::NamespaceCreate2Response;
10588
10589 pub use crate::natural::NamespaceCreateResponse;
10590 }
10591
10592 pub struct Create;
10593
10594 impl ::fidl_next::Method for Create {
10595 const ORDINAL: u64 = 4839678630846501113;
10596 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10597 ::fidl_next::protocol::Flexibility::Flexible;
10598
10599 type Protocol = crate::Namespace;
10600
10601 type Request = crate::wire::NamespaceCreateRequest<'static>;
10602 }
10603
10604 impl ::fidl_next::TwoWayMethod for Create {
10605 type Response = ::fidl_next::wire::Result<
10606 'static,
10607 crate::wire::NamespaceCreateResponse<'static>,
10608 crate::wire::NamespaceError,
10609 >;
10610 }
10611
10612 impl<___R> ::fidl_next::Respond<___R> for Create {
10613 type Output = ::core::result::Result<
10614 crate::generic::NamespaceCreateResponse<___R>,
10615 ::fidl_next::never::Never,
10616 >;
10617
10618 fn respond(response: ___R) -> Self::Output {
10619 ::core::result::Result::Ok(crate::generic::NamespaceCreateResponse {
10620 entries: response,
10621 })
10622 }
10623 }
10624
10625 impl<___R> ::fidl_next::RespondErr<___R> for Create {
10626 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10627
10628 fn respond_err(response: ___R) -> Self::Output {
10629 ::core::result::Result::Err(response)
10630 }
10631 }
10632
10633 pub struct Create2;
10634
10635 impl ::fidl_next::Method for Create2 {
10636 const ORDINAL: u64 = 7375388463768777553;
10637 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10638 ::fidl_next::protocol::Flexibility::Flexible;
10639
10640 type Protocol = crate::Namespace;
10641
10642 type Request = crate::wire::NamespaceCreate2Request<'static>;
10643 }
10644
10645 impl ::fidl_next::TwoWayMethod for Create2 {
10646 type Response = ::fidl_next::wire::Result<
10647 'static,
10648 crate::wire::NamespaceCreate2Response<'static>,
10649 crate::wire::NamespaceError,
10650 >;
10651 }
10652
10653 impl<___R> ::fidl_next::Respond<___R> for Create2 {
10654 type Output = ::core::result::Result<
10655 crate::generic::NamespaceCreate2Response<___R>,
10656 ::fidl_next::never::Never,
10657 >;
10658
10659 fn respond(response: ___R) -> Self::Output {
10660 ::core::result::Result::Ok(crate::generic::NamespaceCreate2Response {
10661 entries: response,
10662 })
10663 }
10664 }
10665
10666 impl<___R> ::fidl_next::RespondErr<___R> for Create2 {
10667 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10668
10669 fn respond_err(response: ___R) -> Self::Output {
10670 ::core::result::Result::Err(response)
10671 }
10672 }
10673
10674 mod ___detail {
10675 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Namespace
10676 where
10677 ___T: ::fidl_next::Transport,
10678 {
10679 type Client = NamespaceClient<___T>;
10680 type Server = NamespaceServer<___T>;
10681 }
10682
10683 #[repr(transparent)]
10685 pub struct NamespaceClient<___T: ::fidl_next::Transport> {
10686 #[allow(dead_code)]
10687 client: ::fidl_next::protocol::Client<___T>,
10688 }
10689
10690 impl<___T> NamespaceClient<___T>
10691 where
10692 ___T: ::fidl_next::Transport,
10693 {
10694 pub fn create(
10695 &self,
10696
10697 entries: impl ::fidl_next::Encode<
10698 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
10699 <___T as ::fidl_next::Transport>::SendBuffer,
10700 >,
10701 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
10702 where
10703 <___T as ::fidl_next::Transport>::SendBuffer:
10704 ::fidl_next::encoder::InternalHandleEncoder,
10705 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10706 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10707 {
10708 self.create_with(crate::generic::NamespaceCreateRequest { entries })
10709 }
10710
10711 pub fn create_with<___R>(
10712 &self,
10713 request: ___R,
10714 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
10715 where
10716 ___R: ::fidl_next::Encode<
10717 crate::wire::NamespaceCreateRequest<'static>,
10718 <___T as ::fidl_next::Transport>::SendBuffer,
10719 >,
10720 {
10721 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10722 4839678630846501113,
10723 <super::Create as ::fidl_next::Method>::FLEXIBILITY,
10724 request,
10725 ))
10726 }
10727
10728 pub fn create2(
10729 &self,
10730
10731 entries: impl ::fidl_next::Encode<
10732 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
10733 <___T as ::fidl_next::Transport>::SendBuffer,
10734 >,
10735 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
10736 where
10737 <___T as ::fidl_next::Transport>::SendBuffer:
10738 ::fidl_next::encoder::InternalHandleEncoder,
10739 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10740 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10741 {
10742 self.create2_with(crate::generic::NamespaceCreate2Request { entries })
10743 }
10744
10745 pub fn create2_with<___R>(
10746 &self,
10747 request: ___R,
10748 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
10749 where
10750 ___R: ::fidl_next::Encode<
10751 crate::wire::NamespaceCreate2Request<'static>,
10752 <___T as ::fidl_next::Transport>::SendBuffer,
10753 >,
10754 {
10755 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10756 7375388463768777553,
10757 <super::Create2 as ::fidl_next::Method>::FLEXIBILITY,
10758 request,
10759 ))
10760 }
10761 }
10762
10763 #[repr(transparent)]
10765 pub struct NamespaceServer<___T: ::fidl_next::Transport> {
10766 server: ::fidl_next::protocol::Server<___T>,
10767 }
10768
10769 impl<___T> NamespaceServer<___T> where ___T: ::fidl_next::Transport {}
10770 }
10771}
10772
10773#[diagnostic::on_unimplemented(
10774 note = "If {Self} implements the non-local NamespaceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10775)]
10776
10777pub trait NamespaceLocalClientHandler<
10781 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10782 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10783>
10784{
10785 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10786 ::core::future::ready(())
10787 }
10788}
10789
10790impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Namespace
10791where
10792 ___H: NamespaceLocalClientHandler<___T>,
10793 ___T: ::fidl_next::Transport,
10794{
10795 async fn on_event(
10796 handler: &mut ___H,
10797 mut message: ::fidl_next::Message<___T>,
10798 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10799 match *message.header().ordinal {
10800 ordinal => {
10801 handler.on_unknown_interaction(ordinal).await;
10802 if ::core::matches!(
10803 message.header().flexibility(),
10804 ::fidl_next::protocol::Flexibility::Strict
10805 ) {
10806 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10807 } else {
10808 Ok(())
10809 }
10810 }
10811 }
10812 }
10813}
10814
10815#[diagnostic::on_unimplemented(
10816 note = "If {Self} implements the non-local NamespaceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
10817)]
10818
10819pub trait NamespaceLocalServerHandler<
10823 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10824 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10825>
10826{
10827 fn create(
10828 &mut self,
10829
10830 request: ::fidl_next::Request<namespace::Create, ___T>,
10831
10832 responder: ::fidl_next::Responder<namespace::Create, ___T>,
10833 ) -> impl ::core::future::Future<Output = ()>;
10834
10835 fn create2(
10836 &mut self,
10837
10838 request: ::fidl_next::Request<namespace::Create2, ___T>,
10839
10840 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
10841 ) -> impl ::core::future::Future<Output = ()>;
10842
10843 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
10844 ::core::future::ready(())
10845 }
10846}
10847
10848impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Namespace
10849where
10850 ___H: NamespaceLocalServerHandler<___T>,
10851 ___T: ::fidl_next::Transport,
10852 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
10853 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10854 Constraint = (),
10855 >,
10856 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
10857 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10858 Constraint = (),
10859 >,
10860{
10861 async fn on_one_way(
10862 handler: &mut ___H,
10863 mut message: ::fidl_next::Message<___T>,
10864 ) -> ::core::result::Result<
10865 (),
10866 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10867 > {
10868 match *message.header().ordinal {
10869 ordinal => {
10870 handler.on_unknown_interaction(ordinal).await;
10871 if ::core::matches!(
10872 message.header().flexibility(),
10873 ::fidl_next::protocol::Flexibility::Strict
10874 ) {
10875 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10876 } else {
10877 Ok(())
10878 }
10879 }
10880 }
10881 }
10882
10883 async fn on_two_way(
10884 handler: &mut ___H,
10885 mut message: ::fidl_next::Message<___T>,
10886 responder: ::fidl_next::protocol::Responder<___T>,
10887 ) -> ::core::result::Result<
10888 (),
10889 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10890 > {
10891 match *message.header().ordinal {
10892 4839678630846501113 => {
10893 let responder = ::fidl_next::Responder::from_untyped(responder);
10894
10895 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10896 Ok(decoded) => {
10897 handler
10898 .create(::fidl_next::Request::from_decoded(decoded), responder)
10899 .await;
10900 Ok(())
10901 }
10902 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10903 ordinal: 4839678630846501113,
10904 error,
10905 }),
10906 }
10907 }
10908
10909 7375388463768777553 => {
10910 let responder = ::fidl_next::Responder::from_untyped(responder);
10911
10912 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10913 Ok(decoded) => {
10914 handler
10915 .create2(::fidl_next::Request::from_decoded(decoded), responder)
10916 .await;
10917 Ok(())
10918 }
10919 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10920 ordinal: 7375388463768777553,
10921 error,
10922 }),
10923 }
10924 }
10925
10926 ordinal => {
10927 handler.on_unknown_interaction(ordinal).await;
10928 if ::core::matches!(
10929 message.header().flexibility(),
10930 ::fidl_next::protocol::Flexibility::Strict
10931 ) {
10932 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10933 } else {
10934 responder
10935 .respond_framework_error(
10936 ordinal,
10937 ::fidl_next::FrameworkError::UnknownMethod,
10938 )
10939 .expect("encoding a framework error should never fail")
10940 .await?;
10941 Ok(())
10942 }
10943 }
10944 }
10945 }
10946}
10947
10948pub trait NamespaceClientHandler<
10952 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10953 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10954>
10955{
10956 fn on_unknown_interaction(
10957 &mut self,
10958 ordinal: u64,
10959 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10960 ::core::future::ready(())
10961 }
10962}
10963
10964impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Namespace
10965where
10966 ___H: NamespaceClientHandler<___T> + ::core::marker::Send,
10967 ___T: ::fidl_next::Transport,
10968{
10969 async fn on_event(
10970 handler: &mut ___H,
10971 mut message: ::fidl_next::Message<___T>,
10972 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10973 match *message.header().ordinal {
10974 ordinal => {
10975 handler.on_unknown_interaction(ordinal).await;
10976 if ::core::matches!(
10977 message.header().flexibility(),
10978 ::fidl_next::protocol::Flexibility::Strict
10979 ) {
10980 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10981 } else {
10982 Ok(())
10983 }
10984 }
10985 }
10986 }
10987}
10988
10989pub trait NamespaceServerHandler<
10993 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10994 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10995>
10996{
10997 fn create(
10998 &mut self,
10999
11000 request: ::fidl_next::Request<namespace::Create, ___T>,
11001
11002 responder: ::fidl_next::Responder<namespace::Create, ___T>,
11003 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11004
11005 fn create2(
11006 &mut self,
11007
11008 request: ::fidl_next::Request<namespace::Create2, ___T>,
11009
11010 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
11011 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11012
11013 fn on_unknown_interaction(
11014 &mut self,
11015 ordinal: u64,
11016 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
11017 ::core::future::ready(())
11018 }
11019}
11020
11021impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Namespace
11022where
11023 ___H: NamespaceServerHandler<___T> + ::core::marker::Send,
11024 ___T: ::fidl_next::Transport,
11025 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
11026 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11027 Constraint = (),
11028 >,
11029 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
11030 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11031 Constraint = (),
11032 >,
11033{
11034 async fn on_one_way(
11035 handler: &mut ___H,
11036 mut message: ::fidl_next::Message<___T>,
11037 ) -> ::core::result::Result<
11038 (),
11039 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11040 > {
11041 match *message.header().ordinal {
11042 ordinal => {
11043 handler.on_unknown_interaction(ordinal).await;
11044 if ::core::matches!(
11045 message.header().flexibility(),
11046 ::fidl_next::protocol::Flexibility::Strict
11047 ) {
11048 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11049 } else {
11050 Ok(())
11051 }
11052 }
11053 }
11054 }
11055
11056 async fn on_two_way(
11057 handler: &mut ___H,
11058 mut message: ::fidl_next::Message<___T>,
11059 responder: ::fidl_next::protocol::Responder<___T>,
11060 ) -> ::core::result::Result<
11061 (),
11062 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11063 > {
11064 match *message.header().ordinal {
11065 4839678630846501113 => {
11066 let responder = ::fidl_next::Responder::from_untyped(responder);
11067
11068 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11069 Ok(decoded) => {
11070 handler
11071 .create(::fidl_next::Request::from_decoded(decoded), responder)
11072 .await;
11073 Ok(())
11074 }
11075 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11076 ordinal: 4839678630846501113,
11077 error,
11078 }),
11079 }
11080 }
11081
11082 7375388463768777553 => {
11083 let responder = ::fidl_next::Responder::from_untyped(responder);
11084
11085 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11086 Ok(decoded) => {
11087 handler
11088 .create2(::fidl_next::Request::from_decoded(decoded), responder)
11089 .await;
11090 Ok(())
11091 }
11092 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11093 ordinal: 7375388463768777553,
11094 error,
11095 }),
11096 }
11097 }
11098
11099 ordinal => {
11100 handler.on_unknown_interaction(ordinal).await;
11101 if ::core::matches!(
11102 message.header().flexibility(),
11103 ::fidl_next::protocol::Flexibility::Strict
11104 ) {
11105 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
11106 } else {
11107 responder
11108 .respond_framework_error(
11109 ordinal,
11110 ::fidl_next::FrameworkError::UnknownMethod,
11111 )
11112 .expect("encoding a framework error should never fail")
11113 .await?;
11114 Ok(())
11115 }
11116 }
11117 }
11118 }
11119}
11120
11121impl<___T> NamespaceClientHandler<___T> for ::fidl_next::IgnoreEvents
11122where
11123 ___T: ::fidl_next::Transport,
11124{
11125 async fn on_unknown_interaction(&mut self, _: u64) {}
11126}
11127
11128impl<___H, ___T> NamespaceLocalClientHandler<___T> for ::fidl_next::Local<___H>
11129where
11130 ___H: NamespaceClientHandler<___T>,
11131 ___T: ::fidl_next::Transport,
11132{
11133 async fn on_unknown_interaction(&mut self, ordinal: u64) {
11134 ___H::on_unknown_interaction(&mut self.0, ordinal).await
11135 }
11136}
11137
11138impl<___H, ___T> NamespaceLocalServerHandler<___T> for ::fidl_next::Local<___H>
11139where
11140 ___H: NamespaceServerHandler<___T>,
11141 ___T: ::fidl_next::Transport,
11142{
11143 async fn create(
11144 &mut self,
11145
11146 request: ::fidl_next::Request<namespace::Create, ___T>,
11147
11148 responder: ::fidl_next::Responder<namespace::Create, ___T>,
11149 ) {
11150 ___H::create(&mut self.0, request, responder).await
11151 }
11152
11153 async fn create2(
11154 &mut self,
11155
11156 request: ::fidl_next::Request<namespace::Create2, ___T>,
11157
11158 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
11159 ) {
11160 ___H::create2(&mut self.0, request, responder).await
11161 }
11162
11163 async fn on_unknown_interaction(&mut self, ordinal: u64) {
11164 ___H::on_unknown_interaction(&mut self.0, ordinal).await
11165 }
11166}
11167
11168#[doc = " A protocol used by a component instance to manage its own realm, such as for\n binding to its children.\n\n Requests to this protocol are processed in the order they are received.\n Clients that wish to send requests in parallel should open multiple\n connections.\n\n The component framework provides this service to components that use\n `fuchsia.component.Realm`.\n"]
11170#[derive(PartialEq, Debug)]
11171pub struct Realm;
11172
11173impl ::fidl_next::Discoverable for Realm {
11174 const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
11175}
11176
11177#[cfg(target_os = "fuchsia")]
11178impl ::fidl_next::HasTransport for Realm {
11179 type Transport = ::fidl_next::fuchsia::zx::Channel;
11180}
11181
11182pub mod realm {
11183 pub mod prelude {
11184 pub use crate::{
11185 Realm, RealmClientHandler, RealmLocalClientHandler, RealmLocalServerHandler,
11186 RealmServerHandler, realm,
11187 };
11188
11189 pub use crate::natural::Error;
11190
11191 pub use crate::natural::RealmCreateChildRequest;
11192
11193 pub use crate::natural::RealmDestroyChildRequest;
11194
11195 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
11196
11197 pub use crate::natural::RealmGetChildOutputDictionaryRequest;
11198
11199 pub use crate::natural::RealmListChildrenRequest;
11200
11201 pub use crate::natural::RealmOpenControllerRequest;
11202
11203 pub use crate::natural::RealmOpenExposedDirRequest;
11204
11205 pub use crate::natural::RealmCreateChildResponse;
11206
11207 pub use crate::natural::RealmDestroyChildResponse;
11208
11209 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
11210
11211 pub use crate::natural::RealmGetChildOutputDictionaryResponse;
11212
11213 pub use crate::natural::RealmGetResolvedInfoResponse;
11214
11215 pub use crate::natural::RealmListChildrenResponse;
11216
11217 pub use crate::natural::RealmOpenControllerResponse;
11218
11219 pub use crate::natural::RealmOpenExposedDirResponse;
11220 }
11221
11222 pub struct OpenController;
11223
11224 impl ::fidl_next::Method for OpenController {
11225 const ORDINAL: u64 = 8165227925828473216;
11226 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11227 ::fidl_next::protocol::Flexibility::Strict;
11228
11229 type Protocol = crate::Realm;
11230
11231 type Request = crate::wire::RealmOpenControllerRequest<'static>;
11232 }
11233
11234 impl ::fidl_next::TwoWayMethod for OpenController {
11235 type Response = ::fidl_next::wire::Result<
11236 'static,
11237 crate::wire::RealmOpenControllerResponse,
11238 crate::wire::Error,
11239 >;
11240 }
11241
11242 impl<___R> ::fidl_next::Respond<___R> for OpenController {
11243 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11244
11245 fn respond(response: ___R) -> Self::Output {
11246 ::core::result::Result::Ok(response)
11247 }
11248 }
11249
11250 impl<___R> ::fidl_next::RespondErr<___R> for OpenController {
11251 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11252
11253 fn respond_err(response: ___R) -> Self::Output {
11254 ::core::result::Result::Err(response)
11255 }
11256 }
11257
11258 pub struct OpenExposedDir;
11259
11260 impl ::fidl_next::Method for OpenExposedDir {
11261 const ORDINAL: u64 = 9194435320863127852;
11262 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11263 ::fidl_next::protocol::Flexibility::Strict;
11264
11265 type Protocol = crate::Realm;
11266
11267 type Request = crate::wire::RealmOpenExposedDirRequest<'static>;
11268 }
11269
11270 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
11271 type Response = ::fidl_next::wire::Result<
11272 'static,
11273 crate::wire::RealmOpenExposedDirResponse,
11274 crate::wire::Error,
11275 >;
11276 }
11277
11278 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
11279 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11280
11281 fn respond(response: ___R) -> Self::Output {
11282 ::core::result::Result::Ok(response)
11283 }
11284 }
11285
11286 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
11287 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11288
11289 fn respond_err(response: ___R) -> Self::Output {
11290 ::core::result::Result::Err(response)
11291 }
11292 }
11293
11294 pub struct CreateChild;
11295
11296 impl ::fidl_next::Method for CreateChild {
11297 const ORDINAL: u64 = 4892190024503489888;
11298 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11299 ::fidl_next::protocol::Flexibility::Strict;
11300
11301 type Protocol = crate::Realm;
11302
11303 type Request = crate::wire::RealmCreateChildRequest<'static>;
11304 }
11305
11306 impl ::fidl_next::TwoWayMethod for CreateChild {
11307 type Response = ::fidl_next::wire::Result<
11308 'static,
11309 crate::wire::RealmCreateChildResponse,
11310 crate::wire::Error,
11311 >;
11312 }
11313
11314 impl<___R> ::fidl_next::Respond<___R> for CreateChild {
11315 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11316
11317 fn respond(response: ___R) -> Self::Output {
11318 ::core::result::Result::Ok(response)
11319 }
11320 }
11321
11322 impl<___R> ::fidl_next::RespondErr<___R> for CreateChild {
11323 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11324
11325 fn respond_err(response: ___R) -> Self::Output {
11326 ::core::result::Result::Err(response)
11327 }
11328 }
11329
11330 pub struct DestroyChild;
11331
11332 impl ::fidl_next::Method for DestroyChild {
11333 const ORDINAL: u64 = 8203529889988252194;
11334 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11335 ::fidl_next::protocol::Flexibility::Strict;
11336
11337 type Protocol = crate::Realm;
11338
11339 type Request = crate::wire::RealmDestroyChildRequest<'static>;
11340 }
11341
11342 impl ::fidl_next::TwoWayMethod for DestroyChild {
11343 type Response = ::fidl_next::wire::Result<
11344 'static,
11345 crate::wire::RealmDestroyChildResponse,
11346 crate::wire::Error,
11347 >;
11348 }
11349
11350 impl<___R> ::fidl_next::Respond<___R> for DestroyChild {
11351 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11352
11353 fn respond(response: ___R) -> Self::Output {
11354 ::core::result::Result::Ok(response)
11355 }
11356 }
11357
11358 impl<___R> ::fidl_next::RespondErr<___R> for DestroyChild {
11359 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11360
11361 fn respond_err(response: ___R) -> Self::Output {
11362 ::core::result::Result::Err(response)
11363 }
11364 }
11365
11366 pub struct ListChildren;
11367
11368 impl ::fidl_next::Method for ListChildren {
11369 const ORDINAL: u64 = 7532454435519185057;
11370 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11371 ::fidl_next::protocol::Flexibility::Strict;
11372
11373 type Protocol = crate::Realm;
11374
11375 type Request = crate::wire::RealmListChildrenRequest<'static>;
11376 }
11377
11378 impl ::fidl_next::TwoWayMethod for ListChildren {
11379 type Response = ::fidl_next::wire::Result<
11380 'static,
11381 crate::wire::RealmListChildrenResponse,
11382 crate::wire::Error,
11383 >;
11384 }
11385
11386 impl<___R> ::fidl_next::Respond<___R> for ListChildren {
11387 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11388
11389 fn respond(response: ___R) -> Self::Output {
11390 ::core::result::Result::Ok(response)
11391 }
11392 }
11393
11394 impl<___R> ::fidl_next::RespondErr<___R> for ListChildren {
11395 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11396
11397 fn respond_err(response: ___R) -> Self::Output {
11398 ::core::result::Result::Err(response)
11399 }
11400 }
11401
11402 pub struct GetResolvedInfo;
11403
11404 impl ::fidl_next::Method for GetResolvedInfo {
11405 const ORDINAL: u64 = 8308987710372188322;
11406 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11407 ::fidl_next::protocol::Flexibility::Strict;
11408
11409 type Protocol = crate::Realm;
11410
11411 type Request = ::fidl_next::wire::EmptyMessageBody;
11412 }
11413
11414 impl ::fidl_next::TwoWayMethod for GetResolvedInfo {
11415 type Response = ::fidl_next::wire::Result<
11416 'static,
11417 crate::wire::RealmGetResolvedInfoResponse<'static>,
11418 crate::wire::Error,
11419 >;
11420 }
11421
11422 impl<___R> ::fidl_next::Respond<___R> for GetResolvedInfo {
11423 type Output = ::core::result::Result<
11424 crate::generic::RealmGetResolvedInfoResponse<___R>,
11425 ::fidl_next::never::Never,
11426 >;
11427
11428 fn respond(response: ___R) -> Self::Output {
11429 ::core::result::Result::Ok(crate::generic::RealmGetResolvedInfoResponse {
11430 resolved_info: response,
11431 })
11432 }
11433 }
11434
11435 impl<___R> ::fidl_next::RespondErr<___R> for GetResolvedInfo {
11436 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11437
11438 fn respond_err(response: ___R) -> Self::Output {
11439 ::core::result::Result::Err(response)
11440 }
11441 }
11442
11443 pub struct GetChildOutputDictionaryDeprecated;
11444
11445 impl ::fidl_next::Method for GetChildOutputDictionaryDeprecated {
11446 const ORDINAL: u64 = 4117516026351534948;
11447 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11448 ::fidl_next::protocol::Flexibility::Strict;
11449
11450 type Protocol = crate::Realm;
11451
11452 type Request = crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>;
11453 }
11454
11455 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionaryDeprecated {
11456 type Response = ::fidl_next::wire::Result<
11457 'static,
11458 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
11459 crate::wire::Error,
11460 >;
11461 }
11462
11463 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionaryDeprecated {
11464 type Output = ::core::result::Result<
11465 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse<___R>,
11466 ::fidl_next::never::Never,
11467 >;
11468
11469 fn respond(response: ___R) -> Self::Output {
11470 ::core::result::Result::Ok(
11471 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse {
11472 dictionary: response,
11473 },
11474 )
11475 }
11476 }
11477
11478 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionaryDeprecated {
11479 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11480
11481 fn respond_err(response: ___R) -> Self::Output {
11482 ::core::result::Result::Err(response)
11483 }
11484 }
11485
11486 pub struct GetChildOutputDictionary;
11487
11488 impl ::fidl_next::Method for GetChildOutputDictionary {
11489 const ORDINAL: u64 = 4781081784078915088;
11490 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11491 ::fidl_next::protocol::Flexibility::Strict;
11492
11493 type Protocol = crate::Realm;
11494
11495 type Request = crate::wire::RealmGetChildOutputDictionaryRequest<'static>;
11496 }
11497
11498 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionary {
11499 type Response = ::fidl_next::wire::Result<
11500 'static,
11501 crate::wire::RealmGetChildOutputDictionaryResponse,
11502 crate::wire::Error,
11503 >;
11504 }
11505
11506 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionary {
11507 type Output = ::core::result::Result<
11508 crate::generic::RealmGetChildOutputDictionaryResponse<___R>,
11509 ::fidl_next::never::Never,
11510 >;
11511
11512 fn respond(response: ___R) -> Self::Output {
11513 ::core::result::Result::Ok(crate::generic::RealmGetChildOutputDictionaryResponse {
11514 dictionary: response,
11515 })
11516 }
11517 }
11518
11519 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionary {
11520 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11521
11522 fn respond_err(response: ___R) -> Self::Output {
11523 ::core::result::Result::Err(response)
11524 }
11525 }
11526
11527 mod ___detail {
11528 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Realm
11529 where
11530 ___T: ::fidl_next::Transport,
11531 {
11532 type Client = RealmClient<___T>;
11533 type Server = RealmServer<___T>;
11534 }
11535
11536 #[repr(transparent)]
11538 pub struct RealmClient<___T: ::fidl_next::Transport> {
11539 #[allow(dead_code)]
11540 client: ::fidl_next::protocol::Client<___T>,
11541 }
11542
11543 impl<___T> RealmClient<___T>
11544 where
11545 ___T: ::fidl_next::Transport,
11546 {
11547 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11548 pub fn open_controller(
11549 &self,
11550
11551 child: impl ::fidl_next::Encode<
11552 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
11553 <___T as ::fidl_next::Transport>::SendBuffer,
11554 >,
11555
11556 controller: impl ::fidl_next::Encode<
11557 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
11558 <___T as ::fidl_next::Transport>::SendBuffer,
11559 >,
11560 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
11561 where
11562 <___T as ::fidl_next::Transport>::SendBuffer:
11563 ::fidl_next::encoder::InternalHandleEncoder,
11564 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11565 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11566 {
11567 self.open_controller_with(crate::generic::RealmOpenControllerRequest {
11568 child,
11569
11570 controller,
11571 })
11572 }
11573
11574 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11575 pub fn open_controller_with<___R>(
11576 &self,
11577 request: ___R,
11578 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
11579 where
11580 ___R: ::fidl_next::Encode<
11581 crate::wire::RealmOpenControllerRequest<'static>,
11582 <___T as ::fidl_next::Transport>::SendBuffer,
11583 >,
11584 {
11585 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11586 8165227925828473216,
11587 <super::OpenController as ::fidl_next::Method>::FLEXIBILITY,
11588 request,
11589 ))
11590 }
11591
11592 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11593 pub fn open_exposed_dir(
11594 &self,
11595
11596 child: impl ::fidl_next::Encode<
11597 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
11598 <___T as ::fidl_next::Transport>::SendBuffer,
11599 >,
11600
11601 exposed_dir: impl ::fidl_next::Encode<
11602 ::fidl_next::ServerEnd<
11603 ::fidl_next_fuchsia_io::Directory,
11604 ::fidl_next::wire::fuchsia::Channel,
11605 >,
11606 <___T as ::fidl_next::Transport>::SendBuffer,
11607 >,
11608 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
11609 where
11610 <___T as ::fidl_next::Transport>::SendBuffer:
11611 ::fidl_next::encoder::InternalHandleEncoder,
11612 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11613 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11614 {
11615 self.open_exposed_dir_with(crate::generic::RealmOpenExposedDirRequest {
11616 child,
11617
11618 exposed_dir,
11619 })
11620 }
11621
11622 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11623 pub fn open_exposed_dir_with<___R>(
11624 &self,
11625 request: ___R,
11626 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
11627 where
11628 ___R: ::fidl_next::Encode<
11629 crate::wire::RealmOpenExposedDirRequest<'static>,
11630 <___T as ::fidl_next::Transport>::SendBuffer,
11631 >,
11632 {
11633 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11634 9194435320863127852,
11635 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
11636 request,
11637 ))
11638 }
11639
11640 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11641 pub fn create_child(
11642 &self,
11643
11644 collection: impl ::fidl_next::Encode<
11645 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
11646 <___T as ::fidl_next::Transport>::SendBuffer,
11647 >,
11648
11649 decl: impl ::fidl_next::Encode<
11650 ::fidl_next_fuchsia_component_decl::wire::Child<'static>,
11651 <___T as ::fidl_next::Transport>::SendBuffer,
11652 >,
11653
11654 args: impl ::fidl_next::Encode<
11655 crate::wire::CreateChildArgs<'static>,
11656 <___T as ::fidl_next::Transport>::SendBuffer,
11657 >,
11658 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
11659 where
11660 <___T as ::fidl_next::Transport>::SendBuffer:
11661 ::fidl_next::encoder::InternalHandleEncoder,
11662 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11663 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11664 {
11665 self.create_child_with(crate::generic::RealmCreateChildRequest {
11666 collection,
11667
11668 decl,
11669
11670 args,
11671 })
11672 }
11673
11674 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11675 pub fn create_child_with<___R>(
11676 &self,
11677 request: ___R,
11678 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
11679 where
11680 ___R: ::fidl_next::Encode<
11681 crate::wire::RealmCreateChildRequest<'static>,
11682 <___T as ::fidl_next::Transport>::SendBuffer,
11683 >,
11684 {
11685 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11686 4892190024503489888,
11687 <super::CreateChild as ::fidl_next::Method>::FLEXIBILITY,
11688 request,
11689 ))
11690 }
11691
11692 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11693 pub fn destroy_child(
11694 &self,
11695
11696 child: impl ::fidl_next::Encode<
11697 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
11698 <___T as ::fidl_next::Transport>::SendBuffer,
11699 >,
11700 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
11701 where
11702 <___T as ::fidl_next::Transport>::SendBuffer:
11703 ::fidl_next::encoder::InternalHandleEncoder,
11704 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11705 {
11706 self.destroy_child_with(crate::generic::RealmDestroyChildRequest { child })
11707 }
11708
11709 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11710 pub fn destroy_child_with<___R>(
11711 &self,
11712 request: ___R,
11713 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
11714 where
11715 ___R: ::fidl_next::Encode<
11716 crate::wire::RealmDestroyChildRequest<'static>,
11717 <___T as ::fidl_next::Transport>::SendBuffer,
11718 >,
11719 {
11720 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11721 8203529889988252194,
11722 <super::DestroyChild as ::fidl_next::Method>::FLEXIBILITY,
11723 request,
11724 ))
11725 }
11726
11727 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
11728 pub fn list_children(
11729 &self,
11730
11731 collection: impl ::fidl_next::Encode<
11732 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
11733 <___T as ::fidl_next::Transport>::SendBuffer,
11734 >,
11735
11736 iter: impl ::fidl_next::Encode<
11737 ::fidl_next::ServerEnd<
11738 crate::ChildIterator,
11739 ::fidl_next::wire::fuchsia::Channel,
11740 >,
11741 <___T as ::fidl_next::Transport>::SendBuffer,
11742 >,
11743 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
11744 where
11745 <___T as ::fidl_next::Transport>::SendBuffer:
11746 ::fidl_next::encoder::InternalHandleEncoder,
11747 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11748 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11749 {
11750 self.list_children_with(crate::generic::RealmListChildrenRequest {
11751 collection,
11752
11753 iter,
11754 })
11755 }
11756
11757 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
11758 pub fn list_children_with<___R>(
11759 &self,
11760 request: ___R,
11761 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
11762 where
11763 ___R: ::fidl_next::Encode<
11764 crate::wire::RealmListChildrenRequest<'static>,
11765 <___T as ::fidl_next::Transport>::SendBuffer,
11766 >,
11767 {
11768 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11769 7532454435519185057,
11770 <super::ListChildren as ::fidl_next::Method>::FLEXIBILITY,
11771 request,
11772 ))
11773 }
11774
11775 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11776 pub fn get_resolved_info(
11777 &self,
11778 ) -> ::fidl_next::TwoWayFuture<'_, super::GetResolvedInfo, ___T> {
11779 ::fidl_next::TwoWayFuture::from_untyped(
11780 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
11781 8308987710372188322,
11782 <super::GetResolvedInfo as ::fidl_next::Method>::FLEXIBILITY,
11783 (),
11784 ),
11785 )
11786 }
11787
11788 pub fn get_child_output_dictionary_deprecated(
11789 &self,
11790
11791 child: impl ::fidl_next::Encode<
11792 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
11793 <___T as ::fidl_next::Transport>::SendBuffer,
11794 >,
11795 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
11796 where
11797 <___T as ::fidl_next::Transport>::SendBuffer:
11798 ::fidl_next::encoder::InternalHandleEncoder,
11799 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11800 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11801 {
11802 self.get_child_output_dictionary_deprecated_with(
11803 crate::generic::RealmGetChildOutputDictionaryDeprecatedRequest { child },
11804 )
11805 }
11806
11807 pub fn get_child_output_dictionary_deprecated_with<___R>(
11808 &self,
11809 request: ___R,
11810 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
11811 where
11812 ___R: ::fidl_next::Encode<
11813 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
11814 <___T as ::fidl_next::Transport>::SendBuffer,
11815 >,
11816 {
11817 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11818 4117516026351534948,
11819 <super::GetChildOutputDictionaryDeprecated as ::fidl_next::Method>::FLEXIBILITY,
11820 request,
11821 ))
11822 }
11823
11824 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
11825 pub fn get_child_output_dictionary(
11826 &self,
11827
11828 child: impl ::fidl_next::Encode<
11829 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
11830 <___T as ::fidl_next::Transport>::SendBuffer,
11831 >,
11832 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
11833 where
11834 <___T as ::fidl_next::Transport>::SendBuffer:
11835 ::fidl_next::encoder::InternalHandleEncoder,
11836 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11837 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11838 {
11839 self.get_child_output_dictionary_with(
11840 crate::generic::RealmGetChildOutputDictionaryRequest { child },
11841 )
11842 }
11843
11844 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
11845 pub fn get_child_output_dictionary_with<___R>(
11846 &self,
11847 request: ___R,
11848 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
11849 where
11850 ___R: ::fidl_next::Encode<
11851 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
11852 <___T as ::fidl_next::Transport>::SendBuffer,
11853 >,
11854 {
11855 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11856 4781081784078915088,
11857 <super::GetChildOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
11858 request,
11859 ))
11860 }
11861 }
11862
11863 #[repr(transparent)]
11865 pub struct RealmServer<___T: ::fidl_next::Transport> {
11866 server: ::fidl_next::protocol::Server<___T>,
11867 }
11868
11869 impl<___T> RealmServer<___T> where ___T: ::fidl_next::Transport {}
11870 }
11871}
11872
11873#[diagnostic::on_unimplemented(
11874 note = "If {Self} implements the non-local RealmClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11875)]
11876
11877pub trait RealmLocalClientHandler<
11881 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11882 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11883>
11884{
11885}
11886
11887impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Realm
11888where
11889 ___H: RealmLocalClientHandler<___T>,
11890 ___T: ::fidl_next::Transport,
11891{
11892 async fn on_event(
11893 handler: &mut ___H,
11894 mut message: ::fidl_next::Message<___T>,
11895 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11896 match *message.header().ordinal {
11897 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11898 }
11899 }
11900}
11901
11902#[diagnostic::on_unimplemented(
11903 note = "If {Self} implements the non-local RealmServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11904)]
11905
11906pub trait RealmLocalServerHandler<
11910 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11911 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11912>
11913{
11914 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11915 fn open_controller(
11916 &mut self,
11917
11918 request: ::fidl_next::Request<realm::OpenController, ___T>,
11919
11920 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11921 ) -> impl ::core::future::Future<Output = ()>;
11922
11923 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11924 fn open_exposed_dir(
11925 &mut self,
11926
11927 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11928
11929 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11930 ) -> impl ::core::future::Future<Output = ()>;
11931
11932 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11933 fn create_child(
11934 &mut self,
11935
11936 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11937
11938 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11939 ) -> impl ::core::future::Future<Output = ()>;
11940
11941 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
11942 fn destroy_child(
11943 &mut self,
11944
11945 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11946
11947 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11948 ) -> impl ::core::future::Future<Output = ()>;
11949
11950 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
11951 fn list_children(
11952 &mut self,
11953
11954 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11955
11956 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11957 ) -> impl ::core::future::Future<Output = ()>;
11958
11959 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11960 fn get_resolved_info(
11961 &mut self,
11962
11963 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11964 ) -> impl ::core::future::Future<Output = ()>;
11965
11966 fn get_child_output_dictionary_deprecated(
11967 &mut self,
11968
11969 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11970
11971 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11972 ) -> impl ::core::future::Future<Output = ()>;
11973
11974 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
11975 fn get_child_output_dictionary(
11976 &mut self,
11977
11978 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11979
11980 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11981 ) -> impl ::core::future::Future<Output = ()>;
11982}
11983
11984impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Realm
11985where
11986 ___H: RealmLocalServerHandler<___T>,
11987 ___T: ::fidl_next::Transport,
11988 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
11989 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11990 Constraint = (),
11991 >,
11992 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
11993 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11994 Constraint = (),
11995 >,
11996 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
11997 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11998 Constraint = (),
11999 >,
12000 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
12001 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12002 Constraint = (),
12003 >,
12004 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
12005 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12006 Constraint = (),
12007 >,
12008 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
12009 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12010 Constraint = (),
12011 >,
12012 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
12013 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12014 Constraint = (),
12015 >,
12016{
12017 async fn on_one_way(
12018 handler: &mut ___H,
12019 mut message: ::fidl_next::Message<___T>,
12020 ) -> ::core::result::Result<
12021 (),
12022 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12023 > {
12024 match *message.header().ordinal {
12025 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12026 }
12027 }
12028
12029 async fn on_two_way(
12030 handler: &mut ___H,
12031 mut message: ::fidl_next::Message<___T>,
12032 responder: ::fidl_next::protocol::Responder<___T>,
12033 ) -> ::core::result::Result<
12034 (),
12035 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12036 > {
12037 match *message.header().ordinal {
12038 8165227925828473216 => {
12039 let responder = ::fidl_next::Responder::from_untyped(responder);
12040
12041 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12042 Ok(decoded) => {
12043 handler
12044 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
12045 .await;
12046 Ok(())
12047 }
12048 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12049 ordinal: 8165227925828473216,
12050 error,
12051 }),
12052 }
12053 }
12054
12055 9194435320863127852 => {
12056 let responder = ::fidl_next::Responder::from_untyped(responder);
12057
12058 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12059 Ok(decoded) => {
12060 handler
12061 .open_exposed_dir(
12062 ::fidl_next::Request::from_decoded(decoded),
12063 responder,
12064 )
12065 .await;
12066 Ok(())
12067 }
12068 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12069 ordinal: 9194435320863127852,
12070 error,
12071 }),
12072 }
12073 }
12074
12075 4892190024503489888 => {
12076 let responder = ::fidl_next::Responder::from_untyped(responder);
12077
12078 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12079 Ok(decoded) => {
12080 handler
12081 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
12082 .await;
12083 Ok(())
12084 }
12085 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12086 ordinal: 4892190024503489888,
12087 error,
12088 }),
12089 }
12090 }
12091
12092 8203529889988252194 => {
12093 let responder = ::fidl_next::Responder::from_untyped(responder);
12094
12095 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12096 Ok(decoded) => {
12097 handler
12098 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
12099 .await;
12100 Ok(())
12101 }
12102 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12103 ordinal: 8203529889988252194,
12104 error,
12105 }),
12106 }
12107 }
12108
12109 7532454435519185057 => {
12110 let responder = ::fidl_next::Responder::from_untyped(responder);
12111
12112 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12113 Ok(decoded) => {
12114 handler
12115 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
12116 .await;
12117 Ok(())
12118 }
12119 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12120 ordinal: 7532454435519185057,
12121 error,
12122 }),
12123 }
12124 }
12125
12126 8308987710372188322 => {
12127 let responder = ::fidl_next::Responder::from_untyped(responder);
12128
12129 handler.get_resolved_info(responder).await;
12130 Ok(())
12131 }
12132
12133 4117516026351534948 => {
12134 let responder = ::fidl_next::Responder::from_untyped(responder);
12135
12136 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12137 Ok(decoded) => {
12138 handler
12139 .get_child_output_dictionary_deprecated(
12140 ::fidl_next::Request::from_decoded(decoded),
12141 responder,
12142 )
12143 .await;
12144 Ok(())
12145 }
12146 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12147 ordinal: 4117516026351534948,
12148 error,
12149 }),
12150 }
12151 }
12152
12153 4781081784078915088 => {
12154 let responder = ::fidl_next::Responder::from_untyped(responder);
12155
12156 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12157 Ok(decoded) => {
12158 handler
12159 .get_child_output_dictionary(
12160 ::fidl_next::Request::from_decoded(decoded),
12161 responder,
12162 )
12163 .await;
12164 Ok(())
12165 }
12166 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12167 ordinal: 4781081784078915088,
12168 error,
12169 }),
12170 }
12171 }
12172
12173 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12174 }
12175 }
12176}
12177
12178pub trait RealmClientHandler<
12182 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12183 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12184>
12185{
12186}
12187
12188impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Realm
12189where
12190 ___H: RealmClientHandler<___T> + ::core::marker::Send,
12191 ___T: ::fidl_next::Transport,
12192{
12193 async fn on_event(
12194 handler: &mut ___H,
12195 mut message: ::fidl_next::Message<___T>,
12196 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12197 match *message.header().ordinal {
12198 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12199 }
12200 }
12201}
12202
12203pub trait RealmServerHandler<
12207 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12208 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12209>
12210{
12211 #[doc = " Operate on a child component. See documentation for [`Controller`].\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
12212 fn open_controller(
12213 &mut self,
12214
12215 request: ::fidl_next::Request<realm::OpenController, ___T>,
12216
12217 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
12218 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12219
12220 #[doc = " Opens the exposed directory of a child component. When this function\n successfully returns, `exposed_dir` is bound to a directory that\n contains the capabilities which the child exposed to its realm via\n `ComponentDecl.exposes` (specified via \"expose\" declarations in the\n component\'s manifest). The child component will not start as a result of\n this call.\n\n `exposed_dir` is open as long as `child` exists.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid child reference.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
12221 fn open_exposed_dir(
12222 &mut self,
12223
12224 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
12225
12226 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
12227 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12228
12229 #[doc = " Creates a child component instance dynamically. When this function\n returns successfully, the instance exists, but it may not be running.\n\n The environment of the child instance is determined by the environment\n of the collection. `decl` must not set `environment`.\n\n If `decl.startup == EAGER`, or `collection.durability == SINGLE_RUN`,\n [CreateChild] will start the component and return once the component is\n started. Otherwise, [CreateChild] will return immediately after creating\n the component and will not start or resolve it.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `child`\n is not a valid declaration.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_ALREADY_EXISTS`: `decl.name` already exists in `collection`.\n - `INSTANCE_CANNOT_RESOLVE`: `child`\'s component declaration failed to resolve\n in a `SingleRun` collection.\n - `NO_SPACE`: Could not allocate storage for the new instance.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
12230 fn create_child(
12231 &mut self,
12232
12233 request: ::fidl_next::Request<realm::CreateChild, ___T>,
12234
12235 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
12236 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12237
12238 #[doc = " Destroys a dynamically-created component instance. When this function\n returns, the instance is destroyed and has stopped running. However,\n cleanup of the component\'s resources (such as its isolated storage) may\n happen in the background after this function returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `child` is not a valid reference or does not refer\n to a dynamic instance.\n - `INSTANCE_NOT_FOUND`: `child` does not exist.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n"]
12239 fn destroy_child(
12240 &mut self,
12241
12242 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
12243
12244 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
12245 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12246
12247 #[doc = " Returns an iterator that lists all instances in a collection.\n\n NOTE: The results are not guaranteed to be consistent. Instances may be\n created or destroyed while the iterator is live, but those changes\n won\'t be observed by the iterator after this method returns.\n\n Errors:\n - `INVALID_ARGUMENTS`: `collection` is not a valid reference or `iter`\n does not have `ZX_RIGHT_WAIT`.\n - `COLLECTION_NOT_FOUND`: `collection` does not exist.\n - `INSTANCE_DIED`: This realm no longer exists.\n - If `iter` does not have standard channel rights, this function may\n return `ACCESS_DENIED` or component manager may close `iter`.\n"]
12248 fn list_children(
12249 &mut self,
12250
12251 request: ::fidl_next::Request<realm::ListChildren, ___T>,
12252
12253 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
12254 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12255
12256 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
12257 fn get_resolved_info(
12258 &mut self,
12259
12260 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
12261 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12262
12263 fn get_child_output_dictionary_deprecated(
12264 &mut self,
12265
12266 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
12267
12268 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
12269 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12270
12271 #[doc = " Returns a reference to a child\'s output dictionary, which may be\n interacted with by using the fuchsia.component.runtime.Capabilities API.\n"]
12272 fn get_child_output_dictionary(
12273 &mut self,
12274
12275 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
12276
12277 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
12278 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12279}
12280
12281impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Realm
12282where
12283 ___H: RealmServerHandler<___T> + ::core::marker::Send,
12284 ___T: ::fidl_next::Transport,
12285 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
12286 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12287 Constraint = (),
12288 >,
12289 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
12290 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12291 Constraint = (),
12292 >,
12293 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
12294 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12295 Constraint = (),
12296 >,
12297 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
12298 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12299 Constraint = (),
12300 >,
12301 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
12302 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12303 Constraint = (),
12304 >,
12305 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
12306 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12307 Constraint = (),
12308 >,
12309 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
12310 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12311 Constraint = (),
12312 >,
12313{
12314 async fn on_one_way(
12315 handler: &mut ___H,
12316 mut message: ::fidl_next::Message<___T>,
12317 ) -> ::core::result::Result<
12318 (),
12319 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12320 > {
12321 match *message.header().ordinal {
12322 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12323 }
12324 }
12325
12326 async fn on_two_way(
12327 handler: &mut ___H,
12328 mut message: ::fidl_next::Message<___T>,
12329 responder: ::fidl_next::protocol::Responder<___T>,
12330 ) -> ::core::result::Result<
12331 (),
12332 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12333 > {
12334 match *message.header().ordinal {
12335 8165227925828473216 => {
12336 let responder = ::fidl_next::Responder::from_untyped(responder);
12337
12338 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12339 Ok(decoded) => {
12340 handler
12341 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
12342 .await;
12343 Ok(())
12344 }
12345 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12346 ordinal: 8165227925828473216,
12347 error,
12348 }),
12349 }
12350 }
12351
12352 9194435320863127852 => {
12353 let responder = ::fidl_next::Responder::from_untyped(responder);
12354
12355 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12356 Ok(decoded) => {
12357 handler
12358 .open_exposed_dir(
12359 ::fidl_next::Request::from_decoded(decoded),
12360 responder,
12361 )
12362 .await;
12363 Ok(())
12364 }
12365 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12366 ordinal: 9194435320863127852,
12367 error,
12368 }),
12369 }
12370 }
12371
12372 4892190024503489888 => {
12373 let responder = ::fidl_next::Responder::from_untyped(responder);
12374
12375 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12376 Ok(decoded) => {
12377 handler
12378 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
12379 .await;
12380 Ok(())
12381 }
12382 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12383 ordinal: 4892190024503489888,
12384 error,
12385 }),
12386 }
12387 }
12388
12389 8203529889988252194 => {
12390 let responder = ::fidl_next::Responder::from_untyped(responder);
12391
12392 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12393 Ok(decoded) => {
12394 handler
12395 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
12396 .await;
12397 Ok(())
12398 }
12399 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12400 ordinal: 8203529889988252194,
12401 error,
12402 }),
12403 }
12404 }
12405
12406 7532454435519185057 => {
12407 let responder = ::fidl_next::Responder::from_untyped(responder);
12408
12409 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12410 Ok(decoded) => {
12411 handler
12412 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
12413 .await;
12414 Ok(())
12415 }
12416 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12417 ordinal: 7532454435519185057,
12418 error,
12419 }),
12420 }
12421 }
12422
12423 8308987710372188322 => {
12424 let responder = ::fidl_next::Responder::from_untyped(responder);
12425
12426 handler.get_resolved_info(responder).await;
12427 Ok(())
12428 }
12429
12430 4117516026351534948 => {
12431 let responder = ::fidl_next::Responder::from_untyped(responder);
12432
12433 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12434 Ok(decoded) => {
12435 handler
12436 .get_child_output_dictionary_deprecated(
12437 ::fidl_next::Request::from_decoded(decoded),
12438 responder,
12439 )
12440 .await;
12441 Ok(())
12442 }
12443 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12444 ordinal: 4117516026351534948,
12445 error,
12446 }),
12447 }
12448 }
12449
12450 4781081784078915088 => {
12451 let responder = ::fidl_next::Responder::from_untyped(responder);
12452
12453 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12454 Ok(decoded) => {
12455 handler
12456 .get_child_output_dictionary(
12457 ::fidl_next::Request::from_decoded(decoded),
12458 responder,
12459 )
12460 .await;
12461 Ok(())
12462 }
12463 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12464 ordinal: 4781081784078915088,
12465 error,
12466 }),
12467 }
12468 }
12469
12470 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12471 }
12472 }
12473}
12474
12475impl<___T> RealmClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
12476
12477impl<___H, ___T> RealmLocalClientHandler<___T> for ::fidl_next::Local<___H>
12478where
12479 ___H: RealmClientHandler<___T>,
12480 ___T: ::fidl_next::Transport,
12481{
12482}
12483
12484impl<___H, ___T> RealmLocalServerHandler<___T> for ::fidl_next::Local<___H>
12485where
12486 ___H: RealmServerHandler<___T>,
12487 ___T: ::fidl_next::Transport,
12488{
12489 async fn open_controller(
12490 &mut self,
12491
12492 request: ::fidl_next::Request<realm::OpenController, ___T>,
12493
12494 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
12495 ) {
12496 ___H::open_controller(&mut self.0, request, responder).await
12497 }
12498
12499 async fn open_exposed_dir(
12500 &mut self,
12501
12502 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
12503
12504 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
12505 ) {
12506 ___H::open_exposed_dir(&mut self.0, request, responder).await
12507 }
12508
12509 async fn create_child(
12510 &mut self,
12511
12512 request: ::fidl_next::Request<realm::CreateChild, ___T>,
12513
12514 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
12515 ) {
12516 ___H::create_child(&mut self.0, request, responder).await
12517 }
12518
12519 async fn destroy_child(
12520 &mut self,
12521
12522 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
12523
12524 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
12525 ) {
12526 ___H::destroy_child(&mut self.0, request, responder).await
12527 }
12528
12529 async fn list_children(
12530 &mut self,
12531
12532 request: ::fidl_next::Request<realm::ListChildren, ___T>,
12533
12534 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
12535 ) {
12536 ___H::list_children(&mut self.0, request, responder).await
12537 }
12538
12539 async fn get_resolved_info(
12540 &mut self,
12541
12542 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
12543 ) {
12544 ___H::get_resolved_info(&mut self.0, responder).await
12545 }
12546
12547 async fn get_child_output_dictionary_deprecated(
12548 &mut self,
12549
12550 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
12551
12552 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
12553 ) {
12554 ___H::get_child_output_dictionary_deprecated(&mut self.0, request, responder).await
12555 }
12556
12557 async fn get_child_output_dictionary(
12558 &mut self,
12559
12560 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
12561
12562 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
12563 ) {
12564 ___H::get_child_output_dictionary(&mut self.0, request, responder).await
12565 }
12566}
12567
12568#[derive(PartialEq, Debug)]
12570pub struct StorageAdmin;
12571
12572impl ::fidl_next::Discoverable for StorageAdmin {
12573 const PROTOCOL_NAME: &'static str = "fuchsia.component.StorageAdmin";
12574}
12575
12576#[cfg(target_os = "fuchsia")]
12577impl ::fidl_next::HasTransport for StorageAdmin {
12578 type Transport = ::fidl_next::fuchsia::zx::Channel;
12579}
12580
12581pub mod storage_admin {
12582 pub mod prelude {
12583 pub use crate::{
12584 StorageAdmin, StorageAdminClientHandler, StorageAdminLocalClientHandler,
12585 StorageAdminLocalServerHandler, StorageAdminServerHandler, storage_admin,
12586 };
12587
12588 pub use crate::natural::DeletionError;
12589
12590 pub use crate::natural::Error;
12591
12592 pub use crate::natural::StatusError;
12593
12594 pub use crate::natural::StorageAdminDeleteComponentStorageRequest;
12595
12596 pub use crate::natural::StorageAdminListStorageInRealmRequest;
12597
12598 pub use crate::natural::StorageAdminOpenComponentStorageByIdRequest;
12599
12600 pub use crate::natural::StorageAdminOpenStorageRequest;
12601
12602 pub use crate::natural::StorageAdminDeleteAllStorageContentsResponse;
12603
12604 pub use crate::natural::StorageAdminDeleteComponentStorageResponse;
12605
12606 pub use crate::natural::StorageAdminListStorageInRealmResponse;
12607
12608 pub use crate::natural::StorageAdminOpenComponentStorageByIdResponse;
12609
12610 pub use crate::natural::StorageAdminOpenStorageResponse;
12611
12612 pub use crate::natural::StorageStatus;
12613 }
12614
12615 pub struct OpenStorage;
12616
12617 impl ::fidl_next::Method for OpenStorage {
12618 const ORDINAL: u64 = 7848267339832116087;
12619 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12620 ::fidl_next::protocol::Flexibility::Strict;
12621
12622 type Protocol = crate::StorageAdmin;
12623
12624 type Request = crate::wire::StorageAdminOpenStorageRequest<'static>;
12625 }
12626
12627 impl ::fidl_next::TwoWayMethod for OpenStorage {
12628 type Response = ::fidl_next::wire::Result<
12629 'static,
12630 crate::wire::StorageAdminOpenStorageResponse,
12631 crate::wire::Error,
12632 >;
12633 }
12634
12635 impl<___R> ::fidl_next::Respond<___R> for OpenStorage {
12636 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12637
12638 fn respond(response: ___R) -> Self::Output {
12639 ::core::result::Result::Ok(response)
12640 }
12641 }
12642
12643 impl<___R> ::fidl_next::RespondErr<___R> for OpenStorage {
12644 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12645
12646 fn respond_err(response: ___R) -> Self::Output {
12647 ::core::result::Result::Err(response)
12648 }
12649 }
12650
12651 pub struct ListStorageInRealm;
12652
12653 impl ::fidl_next::Method for ListStorageInRealm {
12654 const ORDINAL: u64 = 8525152599685368827;
12655 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12656 ::fidl_next::protocol::Flexibility::Strict;
12657
12658 type Protocol = crate::StorageAdmin;
12659
12660 type Request = crate::wire::StorageAdminListStorageInRealmRequest<'static>;
12661 }
12662
12663 impl ::fidl_next::TwoWayMethod for ListStorageInRealm {
12664 type Response = ::fidl_next::wire::Result<
12665 'static,
12666 crate::wire::StorageAdminListStorageInRealmResponse,
12667 crate::wire::Error,
12668 >;
12669 }
12670
12671 impl<___R> ::fidl_next::Respond<___R> for ListStorageInRealm {
12672 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12673
12674 fn respond(response: ___R) -> Self::Output {
12675 ::core::result::Result::Ok(response)
12676 }
12677 }
12678
12679 impl<___R> ::fidl_next::RespondErr<___R> for ListStorageInRealm {
12680 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12681
12682 fn respond_err(response: ___R) -> Self::Output {
12683 ::core::result::Result::Err(response)
12684 }
12685 }
12686
12687 pub struct OpenComponentStorageById;
12688
12689 impl ::fidl_next::Method for OpenComponentStorageById {
12690 const ORDINAL: u64 = 5188727505160068593;
12691 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12692 ::fidl_next::protocol::Flexibility::Strict;
12693
12694 type Protocol = crate::StorageAdmin;
12695
12696 type Request = crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>;
12697 }
12698
12699 impl ::fidl_next::TwoWayMethod for OpenComponentStorageById {
12700 type Response = ::fidl_next::wire::Result<
12701 'static,
12702 crate::wire::StorageAdminOpenComponentStorageByIdResponse,
12703 crate::wire::Error,
12704 >;
12705 }
12706
12707 impl<___R> ::fidl_next::Respond<___R> for OpenComponentStorageById {
12708 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12709
12710 fn respond(response: ___R) -> Self::Output {
12711 ::core::result::Result::Ok(response)
12712 }
12713 }
12714
12715 impl<___R> ::fidl_next::RespondErr<___R> for OpenComponentStorageById {
12716 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12717
12718 fn respond_err(response: ___R) -> Self::Output {
12719 ::core::result::Result::Err(response)
12720 }
12721 }
12722
12723 pub struct DeleteComponentStorage;
12724
12725 impl ::fidl_next::Method for DeleteComponentStorage {
12726 const ORDINAL: u64 = 1618975681517712474;
12727 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12728 ::fidl_next::protocol::Flexibility::Strict;
12729
12730 type Protocol = crate::StorageAdmin;
12731
12732 type Request = crate::wire::StorageAdminDeleteComponentStorageRequest<'static>;
12733 }
12734
12735 impl ::fidl_next::TwoWayMethod for DeleteComponentStorage {
12736 type Response = ::fidl_next::wire::Result<
12737 'static,
12738 crate::wire::StorageAdminDeleteComponentStorageResponse,
12739 crate::wire::Error,
12740 >;
12741 }
12742
12743 impl<___R> ::fidl_next::Respond<___R> for DeleteComponentStorage {
12744 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12745
12746 fn respond(response: ___R) -> Self::Output {
12747 ::core::result::Result::Ok(response)
12748 }
12749 }
12750
12751 impl<___R> ::fidl_next::RespondErr<___R> for DeleteComponentStorage {
12752 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12753
12754 fn respond_err(response: ___R) -> Self::Output {
12755 ::core::result::Result::Err(response)
12756 }
12757 }
12758
12759 pub struct GetStatus;
12760
12761 impl ::fidl_next::Method for GetStatus {
12762 const ORDINAL: u64 = 8586643915409794760;
12763 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12764 ::fidl_next::protocol::Flexibility::Strict;
12765
12766 type Protocol = crate::StorageAdmin;
12767
12768 type Request = ::fidl_next::wire::EmptyMessageBody;
12769 }
12770
12771 impl ::fidl_next::TwoWayMethod for GetStatus {
12772 type Response = ::fidl_next::wire::Result<
12773 'static,
12774 crate::wire::StorageStatus<'static>,
12775 crate::wire::StatusError,
12776 >;
12777 }
12778
12779 impl<___R> ::fidl_next::Respond<___R> for GetStatus {
12780 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12781
12782 fn respond(response: ___R) -> Self::Output {
12783 ::core::result::Result::Ok(response)
12784 }
12785 }
12786
12787 impl<___R> ::fidl_next::RespondErr<___R> for GetStatus {
12788 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12789
12790 fn respond_err(response: ___R) -> Self::Output {
12791 ::core::result::Result::Err(response)
12792 }
12793 }
12794
12795 pub struct DeleteAllStorageContents;
12796
12797 impl ::fidl_next::Method for DeleteAllStorageContents {
12798 const ORDINAL: u64 = 3380374508900862683;
12799 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
12800 ::fidl_next::protocol::Flexibility::Strict;
12801
12802 type Protocol = crate::StorageAdmin;
12803
12804 type Request = ::fidl_next::wire::EmptyMessageBody;
12805 }
12806
12807 impl ::fidl_next::TwoWayMethod for DeleteAllStorageContents {
12808 type Response = ::fidl_next::wire::Result<
12809 'static,
12810 crate::wire::StorageAdminDeleteAllStorageContentsResponse,
12811 crate::wire::DeletionError,
12812 >;
12813 }
12814
12815 impl<___R> ::fidl_next::Respond<___R> for DeleteAllStorageContents {
12816 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
12817
12818 fn respond(response: ___R) -> Self::Output {
12819 ::core::result::Result::Ok(response)
12820 }
12821 }
12822
12823 impl<___R> ::fidl_next::RespondErr<___R> for DeleteAllStorageContents {
12824 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
12825
12826 fn respond_err(response: ___R) -> Self::Output {
12827 ::core::result::Result::Err(response)
12828 }
12829 }
12830
12831 mod ___detail {
12832 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageAdmin
12833 where
12834 ___T: ::fidl_next::Transport,
12835 {
12836 type Client = StorageAdminClient<___T>;
12837 type Server = StorageAdminServer<___T>;
12838 }
12839
12840 #[repr(transparent)]
12842 pub struct StorageAdminClient<___T: ::fidl_next::Transport> {
12843 #[allow(dead_code)]
12844 client: ::fidl_next::protocol::Client<___T>,
12845 }
12846
12847 impl<___T> StorageAdminClient<___T>
12848 where
12849 ___T: ::fidl_next::Transport,
12850 {
12851 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
12852 pub fn open_storage(
12853 &self,
12854
12855 relative_moniker: impl ::fidl_next::Encode<
12856 ::fidl_next::wire::String<'static>,
12857 <___T as ::fidl_next::Transport>::SendBuffer,
12858 >,
12859
12860 object: impl ::fidl_next::Encode<
12861 ::fidl_next::ServerEnd<
12862 ::fidl_next_fuchsia_io::Node,
12863 ::fidl_next::wire::fuchsia::Channel,
12864 >,
12865 <___T as ::fidl_next::Transport>::SendBuffer,
12866 >,
12867 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
12868 where
12869 <___T as ::fidl_next::Transport>::SendBuffer:
12870 ::fidl_next::encoder::InternalHandleEncoder,
12871 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12872 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12873 {
12874 self.open_storage_with(crate::generic::StorageAdminOpenStorageRequest {
12875 relative_moniker,
12876
12877 object,
12878 })
12879 }
12880
12881 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
12882 pub fn open_storage_with<___R>(
12883 &self,
12884 request: ___R,
12885 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
12886 where
12887 ___R: ::fidl_next::Encode<
12888 crate::wire::StorageAdminOpenStorageRequest<'static>,
12889 <___T as ::fidl_next::Transport>::SendBuffer,
12890 >,
12891 {
12892 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12893 7848267339832116087,
12894 <super::OpenStorage as ::fidl_next::Method>::FLEXIBILITY,
12895 request,
12896 ))
12897 }
12898
12899 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
12900 pub fn list_storage_in_realm(
12901 &self,
12902
12903 relative_moniker: impl ::fidl_next::Encode<
12904 ::fidl_next::wire::String<'static>,
12905 <___T as ::fidl_next::Transport>::SendBuffer,
12906 >,
12907
12908 iterator: impl ::fidl_next::Encode<
12909 ::fidl_next::ServerEnd<
12910 crate::StorageIterator,
12911 ::fidl_next::wire::fuchsia::Channel,
12912 >,
12913 <___T as ::fidl_next::Transport>::SendBuffer,
12914 >,
12915 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
12916 where
12917 <___T as ::fidl_next::Transport>::SendBuffer:
12918 ::fidl_next::encoder::InternalHandleEncoder,
12919 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12920 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12921 {
12922 self.list_storage_in_realm_with(
12923 crate::generic::StorageAdminListStorageInRealmRequest {
12924 relative_moniker,
12925
12926 iterator,
12927 },
12928 )
12929 }
12930
12931 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
12932 pub fn list_storage_in_realm_with<___R>(
12933 &self,
12934 request: ___R,
12935 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
12936 where
12937 ___R: ::fidl_next::Encode<
12938 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
12939 <___T as ::fidl_next::Transport>::SendBuffer,
12940 >,
12941 {
12942 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12943 8525152599685368827,
12944 <super::ListStorageInRealm as ::fidl_next::Method>::FLEXIBILITY,
12945 request,
12946 ))
12947 }
12948
12949 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
12950 pub fn open_component_storage_by_id(
12951 &self,
12952
12953 id: impl ::fidl_next::Encode<
12954 ::fidl_next::wire::String<'static>,
12955 <___T as ::fidl_next::Transport>::SendBuffer,
12956 >,
12957
12958 object: impl ::fidl_next::Encode<
12959 ::fidl_next::ServerEnd<
12960 ::fidl_next_fuchsia_io::Node,
12961 ::fidl_next::wire::fuchsia::Channel,
12962 >,
12963 <___T as ::fidl_next::Transport>::SendBuffer,
12964 >,
12965 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
12966 where
12967 <___T as ::fidl_next::Transport>::SendBuffer:
12968 ::fidl_next::encoder::InternalHandleEncoder,
12969 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12970 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12971 {
12972 self.open_component_storage_by_id_with(
12973 crate::generic::StorageAdminOpenComponentStorageByIdRequest { id, object },
12974 )
12975 }
12976
12977 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
12978 pub fn open_component_storage_by_id_with<___R>(
12979 &self,
12980 request: ___R,
12981 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
12982 where
12983 ___R: ::fidl_next::Encode<
12984 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
12985 <___T as ::fidl_next::Transport>::SendBuffer,
12986 >,
12987 {
12988 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12989 5188727505160068593,
12990 <super::OpenComponentStorageById as ::fidl_next::Method>::FLEXIBILITY,
12991 request,
12992 ))
12993 }
12994
12995 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
12996 pub fn delete_component_storage(
12997 &self,
12998
12999 relative_moniker: impl ::fidl_next::Encode<
13000 ::fidl_next::wire::String<'static>,
13001 <___T as ::fidl_next::Transport>::SendBuffer,
13002 >,
13003 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
13004 where
13005 <___T as ::fidl_next::Transport>::SendBuffer:
13006 ::fidl_next::encoder::InternalHandleEncoder,
13007 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
13008 {
13009 self.delete_component_storage_with(
13010 crate::generic::StorageAdminDeleteComponentStorageRequest { relative_moniker },
13011 )
13012 }
13013
13014 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
13015 pub fn delete_component_storage_with<___R>(
13016 &self,
13017 request: ___R,
13018 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
13019 where
13020 ___R: ::fidl_next::Encode<
13021 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
13022 <___T as ::fidl_next::Transport>::SendBuffer,
13023 >,
13024 {
13025 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
13026 1618975681517712474,
13027 <super::DeleteComponentStorage as ::fidl_next::Method>::FLEXIBILITY,
13028 request,
13029 ))
13030 }
13031
13032 #[doc = " Get the current status of the storage.\n"]
13033 pub fn get_status(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetStatus, ___T> {
13034 ::fidl_next::TwoWayFuture::from_untyped(
13035 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
13036 8586643915409794760,
13037 <super::GetStatus as ::fidl_next::Method>::FLEXIBILITY,
13038 (),
13039 ),
13040 )
13041 }
13042
13043 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
13044 pub fn delete_all_storage_contents(
13045 &self,
13046 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteAllStorageContents, ___T> {
13047 ::fidl_next::TwoWayFuture::from_untyped(
13048 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
13049 3380374508900862683,
13050 <super::DeleteAllStorageContents as ::fidl_next::Method>::FLEXIBILITY,
13051 (),
13052 ),
13053 )
13054 }
13055 }
13056
13057 #[repr(transparent)]
13059 pub struct StorageAdminServer<___T: ::fidl_next::Transport> {
13060 server: ::fidl_next::protocol::Server<___T>,
13061 }
13062
13063 impl<___T> StorageAdminServer<___T> where ___T: ::fidl_next::Transport {}
13064 }
13065}
13066
13067#[diagnostic::on_unimplemented(
13068 note = "If {Self} implements the non-local StorageAdminClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
13069)]
13070
13071pub trait StorageAdminLocalClientHandler<
13075 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13076 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13077>
13078{
13079}
13080
13081impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageAdmin
13082where
13083 ___H: StorageAdminLocalClientHandler<___T>,
13084 ___T: ::fidl_next::Transport,
13085{
13086 async fn on_event(
13087 handler: &mut ___H,
13088 mut message: ::fidl_next::Message<___T>,
13089 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13090 match *message.header().ordinal {
13091 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13092 }
13093 }
13094}
13095
13096#[diagnostic::on_unimplemented(
13097 note = "If {Self} implements the non-local StorageAdminServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
13098)]
13099
13100pub trait StorageAdminLocalServerHandler<
13104 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13105 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13106>
13107{
13108 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
13109 fn open_storage(
13110 &mut self,
13111
13112 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
13113
13114 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
13115 ) -> impl ::core::future::Future<Output = ()>;
13116
13117 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
13118 fn list_storage_in_realm(
13119 &mut self,
13120
13121 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
13122
13123 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
13124 ) -> impl ::core::future::Future<Output = ()>;
13125
13126 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
13127 fn open_component_storage_by_id(
13128 &mut self,
13129
13130 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
13131
13132 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
13133 ) -> impl ::core::future::Future<Output = ()>;
13134
13135 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
13136 fn delete_component_storage(
13137 &mut self,
13138
13139 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
13140
13141 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
13142 ) -> impl ::core::future::Future<Output = ()>;
13143
13144 #[doc = " Get the current status of the storage.\n"]
13145 fn get_status(
13146 &mut self,
13147
13148 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
13149 ) -> impl ::core::future::Future<Output = ()>;
13150
13151 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
13152 fn delete_all_storage_contents(
13153 &mut self,
13154
13155 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
13156 ) -> impl ::core::future::Future<Output = ()>;
13157}
13158
13159impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageAdmin
13160where
13161 ___H: StorageAdminLocalServerHandler<___T>,
13162 ___T: ::fidl_next::Transport,
13163 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
13164 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13165 Constraint = (),
13166 >,
13167 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
13168 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13169 Constraint = (),
13170 >,
13171 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
13172 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13173 Constraint = (),
13174 >,
13175 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
13176 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13177 Constraint = (),
13178 >,
13179{
13180 async fn on_one_way(
13181 handler: &mut ___H,
13182 mut message: ::fidl_next::Message<___T>,
13183 ) -> ::core::result::Result<
13184 (),
13185 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13186 > {
13187 match *message.header().ordinal {
13188 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13189 }
13190 }
13191
13192 async fn on_two_way(
13193 handler: &mut ___H,
13194 mut message: ::fidl_next::Message<___T>,
13195 responder: ::fidl_next::protocol::Responder<___T>,
13196 ) -> ::core::result::Result<
13197 (),
13198 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13199 > {
13200 match *message.header().ordinal {
13201 7848267339832116087 => {
13202 let responder = ::fidl_next::Responder::from_untyped(responder);
13203
13204 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13205 Ok(decoded) => {
13206 handler
13207 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
13208 .await;
13209 Ok(())
13210 }
13211 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13212 ordinal: 7848267339832116087,
13213 error,
13214 }),
13215 }
13216 }
13217
13218 8525152599685368827 => {
13219 let responder = ::fidl_next::Responder::from_untyped(responder);
13220
13221 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13222 Ok(decoded) => {
13223 handler
13224 .list_storage_in_realm(
13225 ::fidl_next::Request::from_decoded(decoded),
13226 responder,
13227 )
13228 .await;
13229 Ok(())
13230 }
13231 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13232 ordinal: 8525152599685368827,
13233 error,
13234 }),
13235 }
13236 }
13237
13238 5188727505160068593 => {
13239 let responder = ::fidl_next::Responder::from_untyped(responder);
13240
13241 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13242 Ok(decoded) => {
13243 handler
13244 .open_component_storage_by_id(
13245 ::fidl_next::Request::from_decoded(decoded),
13246 responder,
13247 )
13248 .await;
13249 Ok(())
13250 }
13251 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13252 ordinal: 5188727505160068593,
13253 error,
13254 }),
13255 }
13256 }
13257
13258 1618975681517712474 => {
13259 let responder = ::fidl_next::Responder::from_untyped(responder);
13260
13261 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13262 Ok(decoded) => {
13263 handler
13264 .delete_component_storage(
13265 ::fidl_next::Request::from_decoded(decoded),
13266 responder,
13267 )
13268 .await;
13269 Ok(())
13270 }
13271 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13272 ordinal: 1618975681517712474,
13273 error,
13274 }),
13275 }
13276 }
13277
13278 8586643915409794760 => {
13279 let responder = ::fidl_next::Responder::from_untyped(responder);
13280
13281 handler.get_status(responder).await;
13282 Ok(())
13283 }
13284
13285 3380374508900862683 => {
13286 let responder = ::fidl_next::Responder::from_untyped(responder);
13287
13288 handler.delete_all_storage_contents(responder).await;
13289 Ok(())
13290 }
13291
13292 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13293 }
13294 }
13295}
13296
13297pub trait StorageAdminClientHandler<
13301 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13302 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13303>
13304{
13305}
13306
13307impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageAdmin
13308where
13309 ___H: StorageAdminClientHandler<___T> + ::core::marker::Send,
13310 ___T: ::fidl_next::Transport,
13311{
13312 async fn on_event(
13313 handler: &mut ___H,
13314 mut message: ::fidl_next::Message<___T>,
13315 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
13316 match *message.header().ordinal {
13317 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13318 }
13319 }
13320}
13321
13322pub trait StorageAdminServerHandler<
13326 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
13327 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
13328>
13329{
13330 #[doc = " Opens the isolated directory for the given component. The provided\n moniker is relative to the component that declares the storage\n capability. Creates the backing sub-directory for this storage if it\n hasn\'t yet been created.\n"]
13331 fn open_storage(
13332 &mut self,
13333
13334 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
13335
13336 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
13337 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13338
13339 #[doc = " Lists the descendant components under the specified realm that use the\n storage capability. The provided moniker is relative to the component\n that declares the storage capability.\n\n Returns INSTANCE_NOT_FOUND if the realm does not exist, and INVALID_ARGS\n if |relative_moniker| is malformed.\n"]
13340 fn list_storage_in_realm(
13341 &mut self,
13342
13343 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
13344
13345 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
13346 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13347
13348 #[doc = " Opens the isolated directory for the given storage ID. Creates the\n backing sub-directory for this storage if it hasn\'t yet been created.\n"]
13349 fn open_component_storage_by_id(
13350 &mut self,
13351
13352 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
13353
13354 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
13355 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13356
13357 #[doc = " Deletes the contents of the storage for this component. Preserves the\n component\'s subdirectory itself within the storage backing directory.\n The provided moniker is relative to the component that declares the\n storage capability.\n"]
13358 fn delete_component_storage(
13359 &mut self,
13360
13361 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
13362
13363 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
13364 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13365
13366 #[doc = " Get the current status of the storage.\n"]
13367 fn get_status(
13368 &mut self,
13369
13370 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
13371 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13372
13373 #[doc = " Deletes the contents of all the storage. Storage directories are\n retained so any components using storage will be able to continue using\n it to create new files and directories.\n\n Returns Error::INTERNAL only if no storage at all could be cleared.\n Returns successfully even if some errors happen during the deletion\n progress.\n"]
13374 fn delete_all_storage_contents(
13375 &mut self,
13376
13377 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
13378 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
13379}
13380
13381impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageAdmin
13382where
13383 ___H: StorageAdminServerHandler<___T> + ::core::marker::Send,
13384 ___T: ::fidl_next::Transport,
13385 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
13386 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13387 Constraint = (),
13388 >,
13389 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
13390 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13391 Constraint = (),
13392 >,
13393 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
13394 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13395 Constraint = (),
13396 >,
13397 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
13398 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
13399 Constraint = (),
13400 >,
13401{
13402 async fn on_one_way(
13403 handler: &mut ___H,
13404 mut message: ::fidl_next::Message<___T>,
13405 ) -> ::core::result::Result<
13406 (),
13407 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13408 > {
13409 match *message.header().ordinal {
13410 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13411 }
13412 }
13413
13414 async fn on_two_way(
13415 handler: &mut ___H,
13416 mut message: ::fidl_next::Message<___T>,
13417 responder: ::fidl_next::protocol::Responder<___T>,
13418 ) -> ::core::result::Result<
13419 (),
13420 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
13421 > {
13422 match *message.header().ordinal {
13423 7848267339832116087 => {
13424 let responder = ::fidl_next::Responder::from_untyped(responder);
13425
13426 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13427 Ok(decoded) => {
13428 handler
13429 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
13430 .await;
13431 Ok(())
13432 }
13433 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13434 ordinal: 7848267339832116087,
13435 error,
13436 }),
13437 }
13438 }
13439
13440 8525152599685368827 => {
13441 let responder = ::fidl_next::Responder::from_untyped(responder);
13442
13443 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13444 Ok(decoded) => {
13445 handler
13446 .list_storage_in_realm(
13447 ::fidl_next::Request::from_decoded(decoded),
13448 responder,
13449 )
13450 .await;
13451 Ok(())
13452 }
13453 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13454 ordinal: 8525152599685368827,
13455 error,
13456 }),
13457 }
13458 }
13459
13460 5188727505160068593 => {
13461 let responder = ::fidl_next::Responder::from_untyped(responder);
13462
13463 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13464 Ok(decoded) => {
13465 handler
13466 .open_component_storage_by_id(
13467 ::fidl_next::Request::from_decoded(decoded),
13468 responder,
13469 )
13470 .await;
13471 Ok(())
13472 }
13473 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13474 ordinal: 5188727505160068593,
13475 error,
13476 }),
13477 }
13478 }
13479
13480 1618975681517712474 => {
13481 let responder = ::fidl_next::Responder::from_untyped(responder);
13482
13483 match ::fidl_next::AsDecoderExt::into_decoded(message) {
13484 Ok(decoded) => {
13485 handler
13486 .delete_component_storage(
13487 ::fidl_next::Request::from_decoded(decoded),
13488 responder,
13489 )
13490 .await;
13491 Ok(())
13492 }
13493 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
13494 ordinal: 1618975681517712474,
13495 error,
13496 }),
13497 }
13498 }
13499
13500 8586643915409794760 => {
13501 let responder = ::fidl_next::Responder::from_untyped(responder);
13502
13503 handler.get_status(responder).await;
13504 Ok(())
13505 }
13506
13507 3380374508900862683 => {
13508 let responder = ::fidl_next::Responder::from_untyped(responder);
13509
13510 handler.delete_all_storage_contents(responder).await;
13511 Ok(())
13512 }
13513
13514 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
13515 }
13516 }
13517}
13518
13519impl<___T> StorageAdminClientHandler<___T> for ::fidl_next::IgnoreEvents where
13520 ___T: ::fidl_next::Transport
13521{
13522}
13523
13524impl<___H, ___T> StorageAdminLocalClientHandler<___T> for ::fidl_next::Local<___H>
13525where
13526 ___H: StorageAdminClientHandler<___T>,
13527 ___T: ::fidl_next::Transport,
13528{
13529}
13530
13531impl<___H, ___T> StorageAdminLocalServerHandler<___T> for ::fidl_next::Local<___H>
13532where
13533 ___H: StorageAdminServerHandler<___T>,
13534 ___T: ::fidl_next::Transport,
13535{
13536 async fn open_storage(
13537 &mut self,
13538
13539 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
13540
13541 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
13542 ) {
13543 ___H::open_storage(&mut self.0, request, responder).await
13544 }
13545
13546 async fn list_storage_in_realm(
13547 &mut self,
13548
13549 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
13550
13551 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
13552 ) {
13553 ___H::list_storage_in_realm(&mut self.0, request, responder).await
13554 }
13555
13556 async fn open_component_storage_by_id(
13557 &mut self,
13558
13559 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
13560
13561 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
13562 ) {
13563 ___H::open_component_storage_by_id(&mut self.0, request, responder).await
13564 }
13565
13566 async fn delete_component_storage(
13567 &mut self,
13568
13569 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
13570
13571 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
13572 ) {
13573 ___H::delete_component_storage(&mut self.0, request, responder).await
13574 }
13575
13576 async fn get_status(
13577 &mut self,
13578
13579 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
13580 ) {
13581 ___H::get_status(&mut self.0, responder).await
13582 }
13583
13584 async fn delete_all_storage_contents(
13585 &mut self,
13586
13587 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
13588 ) {
13589 ___H::delete_all_storage_contents(&mut self.0, responder).await
13590 }
13591}
13592
13593pub use fidl_next_common_fuchsia_component::*;