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 capability(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
3383 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3384 }
3385 }
3386
3387 impl<'de> ::core::fmt::Debug for CapabilityRequestedPayload<'de> {
3388 fn fmt(
3389 &self,
3390 f: &mut ::core::fmt::Formatter<'_>,
3391 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3392 f.debug_struct("CapabilityRequestedPayload")
3393 .field("name", &self.name())
3394 .field("capability", &self.capability())
3395 .finish()
3396 }
3397 }
3398
3399 impl<'de> ::fidl_next::IntoNatural for CapabilityRequestedPayload<'de> {
3400 type Natural = crate::natural::CapabilityRequestedPayload;
3401 }
3402
3403 #[derive(Debug)]
3405 #[repr(C)]
3406 pub struct ControllerIsStartedResponse {
3407 pub is_started: bool,
3408 }
3409
3410 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerIsStartedResponse>(), 1);
3411 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerIsStartedResponse>(), 1);
3412
3413 static_assertions::const_assert_eq!(
3414 std::mem::offset_of!(ControllerIsStartedResponse, is_started),
3415 0
3416 );
3417
3418 impl ::fidl_next::Constrained for ControllerIsStartedResponse {
3419 type Constraint = ();
3420
3421 fn validate(
3422 _: ::fidl_next::Slot<'_, Self>,
3423 _: Self::Constraint,
3424 ) -> Result<(), ::fidl_next::ValidationError> {
3425 Ok(())
3426 }
3427 }
3428
3429 unsafe impl ::fidl_next::Wire for ControllerIsStartedResponse {
3430 type Narrowed<'de> = ControllerIsStartedResponse;
3431
3432 #[inline]
3433 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3434 ::fidl_next::munge! {
3435 let Self {
3436 is_started,
3437
3438 } = &mut *out_;
3439 }
3440
3441 ::fidl_next::Wire::zero_padding(is_started);
3442 }
3443 }
3444
3445 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerIsStartedResponse
3446 where
3447 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3448 ___D: ::fidl_next::fuchsia::HandleDecoder,
3449 {
3450 fn decode(
3451 slot_: ::fidl_next::Slot<'_, Self>,
3452 decoder_: &mut ___D,
3453 _: (),
3454 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3455 ::fidl_next::munge! {
3456 let Self {
3457 mut is_started,
3458
3459 } = slot_;
3460 }
3461
3462 let _field = is_started.as_mut();
3463
3464 ::fidl_next::Decode::decode(is_started.as_mut(), decoder_, ())?;
3465
3466 Ok(())
3467 }
3468 }
3469
3470 impl ::fidl_next::IntoNatural for ControllerIsStartedResponse {
3471 type Natural = crate::natural::ControllerIsStartedResponse;
3472 }
3473
3474 #[derive(Debug)]
3476 #[repr(C)]
3477 pub struct ControllerGetExposedDictionaryResponse {
3478 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3479 }
3480
3481 static_assertions::const_assert_eq!(
3482 std::mem::size_of::<ControllerGetExposedDictionaryResponse>(),
3483 4
3484 );
3485 static_assertions::const_assert_eq!(
3486 std::mem::align_of::<ControllerGetExposedDictionaryResponse>(),
3487 4
3488 );
3489
3490 static_assertions::const_assert_eq!(
3491 std::mem::offset_of!(ControllerGetExposedDictionaryResponse, dictionary),
3492 0
3493 );
3494
3495 impl ::fidl_next::Constrained for ControllerGetExposedDictionaryResponse {
3496 type Constraint = ();
3497
3498 fn validate(
3499 _: ::fidl_next::Slot<'_, Self>,
3500 _: Self::Constraint,
3501 ) -> Result<(), ::fidl_next::ValidationError> {
3502 Ok(())
3503 }
3504 }
3505
3506 unsafe impl ::fidl_next::Wire for ControllerGetExposedDictionaryResponse {
3507 type Narrowed<'de> = ControllerGetExposedDictionaryResponse;
3508
3509 #[inline]
3510 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3511 ::fidl_next::munge! {
3512 let Self {
3513 dictionary,
3514
3515 } = &mut *out_;
3516 }
3517
3518 ::fidl_next::Wire::zero_padding(dictionary);
3519 }
3520 }
3521
3522 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetExposedDictionaryResponse
3523 where
3524 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3525 ___D: ::fidl_next::fuchsia::HandleDecoder,
3526 {
3527 fn decode(
3528 slot_: ::fidl_next::Slot<'_, Self>,
3529 decoder_: &mut ___D,
3530 _: (),
3531 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3532 ::fidl_next::munge! {
3533 let Self {
3534 mut dictionary,
3535
3536 } = slot_;
3537 }
3538
3539 let _field = dictionary.as_mut();
3540
3541 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3542
3543 Ok(())
3544 }
3545 }
3546
3547 impl ::fidl_next::IntoNatural for ControllerGetExposedDictionaryResponse {
3548 type Natural = crate::natural::ControllerGetExposedDictionaryResponse;
3549 }
3550
3551 #[derive(Debug)]
3553 #[repr(C)]
3554 pub struct ControllerGetOutputDictionaryResponse {
3555 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
3556 }
3557
3558 static_assertions::const_assert_eq!(
3559 std::mem::size_of::<ControllerGetOutputDictionaryResponse>(),
3560 4
3561 );
3562 static_assertions::const_assert_eq!(
3563 std::mem::align_of::<ControllerGetOutputDictionaryResponse>(),
3564 4
3565 );
3566
3567 static_assertions::const_assert_eq!(
3568 std::mem::offset_of!(ControllerGetOutputDictionaryResponse, dictionary),
3569 0
3570 );
3571
3572 impl ::fidl_next::Constrained for ControllerGetOutputDictionaryResponse {
3573 type Constraint = ();
3574
3575 fn validate(
3576 _: ::fidl_next::Slot<'_, Self>,
3577 _: Self::Constraint,
3578 ) -> Result<(), ::fidl_next::ValidationError> {
3579 Ok(())
3580 }
3581 }
3582
3583 unsafe impl ::fidl_next::Wire for ControllerGetOutputDictionaryResponse {
3584 type Narrowed<'de> = ControllerGetOutputDictionaryResponse;
3585
3586 #[inline]
3587 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3588 ::fidl_next::munge! {
3589 let Self {
3590 dictionary,
3591
3592 } = &mut *out_;
3593 }
3594
3595 ::fidl_next::Wire::zero_padding(dictionary);
3596 }
3597 }
3598
3599 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetOutputDictionaryResponse
3600 where
3601 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3602 ___D: ::fidl_next::fuchsia::HandleDecoder,
3603 {
3604 fn decode(
3605 slot_: ::fidl_next::Slot<'_, Self>,
3606 decoder_: &mut ___D,
3607 _: (),
3608 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3609 ::fidl_next::munge! {
3610 let Self {
3611 mut dictionary,
3612
3613 } = slot_;
3614 }
3615
3616 let _field = dictionary.as_mut();
3617
3618 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3619
3620 Ok(())
3621 }
3622 }
3623
3624 impl ::fidl_next::IntoNatural for ControllerGetOutputDictionaryResponse {
3625 type Natural = crate::natural::ControllerGetOutputDictionaryResponse;
3626 }
3627
3628 #[repr(C)]
3630 pub struct NamespaceEntry<'de> {
3631 pub(crate) table: ::fidl_next::wire::Table<'de>,
3632 }
3633
3634 impl<'de> Drop for NamespaceEntry<'de> {
3635 fn drop(&mut self) {
3636 let _ = self.table.get(1).map(|envelope| unsafe {
3637 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3638 });
3639
3640 let _ = self.table.get(2).map(|envelope| unsafe {
3641 envelope.read_unchecked::<::fidl_next::ClientEnd<
3642 ::fidl_next_fuchsia_io::Directory,
3643 ::fidl_next::wire::fuchsia::Channel,
3644 >>()
3645 });
3646 }
3647 }
3648
3649 impl ::fidl_next::Constrained for NamespaceEntry<'_> {
3650 type Constraint = ();
3651
3652 fn validate(
3653 _: ::fidl_next::Slot<'_, Self>,
3654 _: Self::Constraint,
3655 ) -> Result<(), ::fidl_next::ValidationError> {
3656 Ok(())
3657 }
3658 }
3659
3660 unsafe impl ::fidl_next::Wire for NamespaceEntry<'static> {
3661 type Narrowed<'de> = NamespaceEntry<'de>;
3662
3663 #[inline]
3664 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3665 ::fidl_next::munge!(let Self { table } = out);
3666 ::fidl_next::wire::Table::zero_padding(table);
3667 }
3668 }
3669
3670 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceEntry<'de>
3671 where
3672 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3673 ___D: ::fidl_next::fuchsia::HandleDecoder,
3674 {
3675 fn decode(
3676 slot: ::fidl_next::Slot<'_, Self>,
3677 decoder: &mut ___D,
3678 _: (),
3679 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3680 ::fidl_next::munge!(let Self { table } = slot);
3681
3682 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3683 match ordinal {
3684 0 => unsafe { ::core::hint::unreachable_unchecked() },
3685
3686 1 => {
3687 ::fidl_next::wire::Envelope::decode_as::<
3688 ___D,
3689 ::fidl_next::wire::String<'de>,
3690 >(slot.as_mut(), decoder, 4095)?;
3691
3692 let value = unsafe {
3693 slot.deref_unchecked()
3694 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3695 };
3696
3697 if value.len() > 4095 {
3698 return Err(::fidl_next::DecodeError::VectorTooLong {
3699 size: value.len() as u64,
3700 limit: 4095,
3701 });
3702 }
3703
3704 Ok(())
3705 }
3706
3707 2 => {
3708 ::fidl_next::wire::Envelope::decode_as::<
3709 ___D,
3710 ::fidl_next::ClientEnd<
3711 ::fidl_next_fuchsia_io::Directory,
3712 ::fidl_next::wire::fuchsia::Channel,
3713 >,
3714 >(slot.as_mut(), decoder, ())?;
3715
3716 Ok(())
3717 }
3718
3719 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3720 }
3721 })
3722 }
3723 }
3724
3725 impl<'de> NamespaceEntry<'de> {
3726 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3727 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3728 }
3729
3730 pub fn directory(
3731 &self,
3732 ) -> ::core::option::Option<
3733 &::fidl_next::ClientEnd<
3734 ::fidl_next_fuchsia_io::Directory,
3735 ::fidl_next::wire::fuchsia::Channel,
3736 >,
3737 > {
3738 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3739 }
3740 }
3741
3742 impl<'de> ::core::fmt::Debug for NamespaceEntry<'de> {
3743 fn fmt(
3744 &self,
3745 f: &mut ::core::fmt::Formatter<'_>,
3746 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3747 f.debug_struct("NamespaceEntry")
3748 .field("path", &self.path())
3749 .field("directory", &self.directory())
3750 .finish()
3751 }
3752 }
3753
3754 impl<'de> ::fidl_next::IntoNatural for NamespaceEntry<'de> {
3755 type Natural = crate::natural::NamespaceEntry;
3756 }
3757
3758 #[repr(C)]
3760 pub struct StartChildArgs<'de> {
3761 pub(crate) table: ::fidl_next::wire::Table<'de>,
3762 }
3763
3764 impl<'de> Drop for StartChildArgs<'de> {
3765 fn drop(&mut self) {
3766 let _ =
3767 self.table.get(1).map(|envelope| unsafe {
3768 envelope.read_unchecked::<::fidl_next::wire::Vector<
3769 'de,
3770 ::fidl_next_fuchsia_process::wire::HandleInfo,
3771 >>()
3772 });
3773
3774 let _ = self.table.get(2)
3775 .map(|envelope| unsafe {
3776 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>()
3777 });
3778
3779 let _ = self.table.get(3)
3780 .map(|envelope| unsafe {
3781 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
3782 });
3783
3784 let _ = self.table.get(4).map(|envelope| unsafe {
3785 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
3786 });
3787 }
3788 }
3789
3790 impl ::fidl_next::Constrained for StartChildArgs<'_> {
3791 type Constraint = ();
3792
3793 fn validate(
3794 _: ::fidl_next::Slot<'_, Self>,
3795 _: Self::Constraint,
3796 ) -> Result<(), ::fidl_next::ValidationError> {
3797 Ok(())
3798 }
3799 }
3800
3801 unsafe impl ::fidl_next::Wire for StartChildArgs<'static> {
3802 type Narrowed<'de> = StartChildArgs<'de>;
3803
3804 #[inline]
3805 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3806 ::fidl_next::munge!(let Self { table } = out);
3807 ::fidl_next::wire::Table::zero_padding(table);
3808 }
3809 }
3810
3811 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartChildArgs<'de>
3812 where
3813 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3814 ___D: ::fidl_next::fuchsia::HandleDecoder,
3815 {
3816 fn decode(
3817 slot: ::fidl_next::Slot<'_, Self>,
3818 decoder: &mut ___D,
3819 _: (),
3820 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3821 ::fidl_next::munge!(let Self { table } = slot);
3822
3823 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3824 match ordinal {
3825 0 => unsafe { ::core::hint::unreachable_unchecked() },
3826
3827 1 => {
3828 ::fidl_next::wire::Envelope::decode_as::<
3829 ___D,
3830 ::fidl_next::wire::Vector<
3831 'de,
3832 ::fidl_next_fuchsia_process::wire::HandleInfo,
3833 >,
3834 >(slot.as_mut(), decoder, (128, ()))?;
3835
3836 let value = unsafe {
3837 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
3838 '_,
3839 ::fidl_next_fuchsia_process::wire::HandleInfo,
3840 >>()
3841 };
3842
3843 if value.len() > 128 {
3844 return Err(::fidl_next::DecodeError::VectorTooLong {
3845 size: value.len() as u64,
3846 limit: 128,
3847 });
3848 }
3849
3850 Ok(())
3851 }
3852
3853 2 => {
3854 ::fidl_next::wire::Envelope::decode_as::<
3855 ___D,
3856 ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
3857 >(slot.as_mut(), decoder, (32, ()))?;
3858
3859 let value = unsafe {
3860 slot
3861 .deref_unchecked()
3862 .deref_unchecked::<
3863 ::fidl_next::wire::Vector<'_, crate::wire::NamespaceEntry<'_>>
3864 >()
3865 };
3866
3867 if value.len() > 32 {
3868 return Err(::fidl_next::DecodeError::VectorTooLong {
3869 size: value.len() as u64,
3870 limit: 32,
3871 });
3872 }
3873
3874 Ok(())
3875 }
3876
3877 3 => {
3878 ::fidl_next::wire::Envelope::decode_as::<
3879 ___D,
3880 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3881 >(slot.as_mut(), decoder, ())?;
3882
3883 Ok(())
3884 }
3885
3886 4 => {
3887 ::fidl_next::wire::Envelope::decode_as::<
3888 ___D,
3889 ::fidl_next::wire::fuchsia::EventPair,
3890 >(slot.as_mut(), decoder, ())?;
3891
3892 Ok(())
3893 }
3894
3895 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3896 }
3897 })
3898 }
3899 }
3900
3901 impl<'de> StartChildArgs<'de> {
3902 pub fn numbered_handles(
3903 &self,
3904 ) -> ::core::option::Option<
3905 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3906 > {
3907 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3908 }
3909
3910 pub fn namespace_entries(
3911 &self,
3912 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3913 {
3914 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3915 }
3916
3917 pub fn dictionary(
3918 &self,
3919 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3920 {
3921 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3922 }
3923
3924 pub fn additional_inputs(
3925 &self,
3926 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
3927 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3928 }
3929 }
3930
3931 impl<'de> ::core::fmt::Debug for StartChildArgs<'de> {
3932 fn fmt(
3933 &self,
3934 f: &mut ::core::fmt::Formatter<'_>,
3935 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3936 f.debug_struct("StartChildArgs")
3937 .field("numbered_handles", &self.numbered_handles())
3938 .field("namespace_entries", &self.namespace_entries())
3939 .field("dictionary", &self.dictionary())
3940 .field("additional_inputs", &self.additional_inputs())
3941 .finish()
3942 }
3943 }
3944
3945 impl<'de> ::fidl_next::IntoNatural for StartChildArgs<'de> {
3946 type Natural = crate::natural::StartChildArgs;
3947 }
3948
3949 #[derive(Debug)]
3951 #[repr(C)]
3952 pub struct ControllerStartRequest<'de> {
3953 pub args: crate::wire::StartChildArgs<'de>,
3954
3955 pub execution_controller:
3956 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::wire::fuchsia::Channel>,
3957 }
3958
3959 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerStartRequest<'_>>(), 24);
3960 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerStartRequest<'_>>(), 8);
3961
3962 static_assertions::const_assert_eq!(std::mem::offset_of!(ControllerStartRequest<'_>, args), 0);
3963
3964 static_assertions::const_assert_eq!(
3965 std::mem::offset_of!(ControllerStartRequest<'_>, execution_controller),
3966 16
3967 );
3968
3969 impl ::fidl_next::Constrained for ControllerStartRequest<'_> {
3970 type Constraint = ();
3971
3972 fn validate(
3973 _: ::fidl_next::Slot<'_, Self>,
3974 _: Self::Constraint,
3975 ) -> Result<(), ::fidl_next::ValidationError> {
3976 Ok(())
3977 }
3978 }
3979
3980 unsafe impl ::fidl_next::Wire for ControllerStartRequest<'static> {
3981 type Narrowed<'de> = ControllerStartRequest<'de>;
3982
3983 #[inline]
3984 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3985 ::fidl_next::munge! {
3986 let Self {
3987 args,
3988 execution_controller,
3989
3990 } = &mut *out_;
3991 }
3992
3993 ::fidl_next::Wire::zero_padding(args);
3994
3995 ::fidl_next::Wire::zero_padding(execution_controller);
3996
3997 unsafe {
3998 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
3999 }
4000 }
4001 }
4002
4003 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ControllerStartRequest<'de>
4004 where
4005 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4006 ___D: ::fidl_next::Decoder<'de>,
4007 ___D: ::fidl_next::fuchsia::HandleDecoder,
4008 {
4009 fn decode(
4010 slot_: ::fidl_next::Slot<'_, Self>,
4011 decoder_: &mut ___D,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4014 if slot_.as_bytes()[20..24] != [0u8; 4] {
4015 return Err(::fidl_next::DecodeError::InvalidPadding);
4016 }
4017
4018 ::fidl_next::munge! {
4019 let Self {
4020 mut args,
4021 mut execution_controller,
4022
4023 } = slot_;
4024 }
4025
4026 let _field = args.as_mut();
4027
4028 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
4029
4030 let _field = execution_controller.as_mut();
4031
4032 ::fidl_next::Decode::decode(execution_controller.as_mut(), decoder_, ())?;
4033
4034 Ok(())
4035 }
4036 }
4037
4038 impl<'de> ::fidl_next::IntoNatural for ControllerStartRequest<'de> {
4039 type Natural = crate::natural::ControllerStartRequest;
4040 }
4041
4042 #[derive(Debug)]
4044 #[repr(C)]
4045 pub struct ControllerOpenExposedDirRequest {
4046 pub exposed_dir: ::fidl_next::ServerEnd<
4047 ::fidl_next_fuchsia_io::Directory,
4048 ::fidl_next::wire::fuchsia::Channel,
4049 >,
4050 }
4051
4052 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerOpenExposedDirRequest>(), 4);
4053 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerOpenExposedDirRequest>(), 4);
4054
4055 static_assertions::const_assert_eq!(
4056 std::mem::offset_of!(ControllerOpenExposedDirRequest, exposed_dir),
4057 0
4058 );
4059
4060 impl ::fidl_next::Constrained for ControllerOpenExposedDirRequest {
4061 type Constraint = ();
4062
4063 fn validate(
4064 _: ::fidl_next::Slot<'_, Self>,
4065 _: Self::Constraint,
4066 ) -> Result<(), ::fidl_next::ValidationError> {
4067 Ok(())
4068 }
4069 }
4070
4071 unsafe impl ::fidl_next::Wire for ControllerOpenExposedDirRequest {
4072 type Narrowed<'de> = ControllerOpenExposedDirRequest;
4073
4074 #[inline]
4075 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4076 ::fidl_next::munge! {
4077 let Self {
4078 exposed_dir,
4079
4080 } = &mut *out_;
4081 }
4082
4083 ::fidl_next::Wire::zero_padding(exposed_dir);
4084 }
4085 }
4086
4087 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerOpenExposedDirRequest
4088 where
4089 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4090 ___D: ::fidl_next::fuchsia::HandleDecoder,
4091 {
4092 fn decode(
4093 slot_: ::fidl_next::Slot<'_, Self>,
4094 decoder_: &mut ___D,
4095 _: (),
4096 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4097 ::fidl_next::munge! {
4098 let Self {
4099 mut exposed_dir,
4100
4101 } = slot_;
4102 }
4103
4104 let _field = exposed_dir.as_mut();
4105
4106 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
4107
4108 Ok(())
4109 }
4110 }
4111
4112 impl ::fidl_next::IntoNatural for ControllerOpenExposedDirRequest {
4113 type Natural = crate::natural::ControllerOpenExposedDirRequest;
4114 }
4115
4116 #[repr(C)]
4118 pub struct CreateChildArgs<'de> {
4119 pub(crate) table: ::fidl_next::wire::Table<'de>,
4120 }
4121
4122 impl<'de> Drop for CreateChildArgs<'de> {
4123 fn drop(&mut self) {
4124 let _ =
4125 self.table.get(1).map(|envelope| unsafe {
4126 envelope.read_unchecked::<::fidl_next::wire::Vector<
4127 'de,
4128 ::fidl_next_fuchsia_process::wire::HandleInfo,
4129 >>()
4130 });
4131
4132 let _ = self.table.get(2).map(|envelope| unsafe {
4133 envelope.read_unchecked::<::fidl_next::wire::Vector<
4134 'de,
4135 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4136 >>()
4137 });
4138
4139 let _ =
4140 self.table.get(3).map(|envelope| unsafe {
4141 envelope.read_unchecked::<::fidl_next::ServerEnd<
4142 crate::Controller,
4143 ::fidl_next::wire::fuchsia::Channel,
4144 >>()
4145 });
4146
4147 let _ = self.table.get(4)
4148 .map(|envelope| unsafe {
4149 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
4150 });
4151
4152 let _ = self.table.get(5).map(|envelope| unsafe {
4153 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4154 });
4155 }
4156 }
4157
4158 impl ::fidl_next::Constrained for CreateChildArgs<'_> {
4159 type Constraint = ();
4160
4161 fn validate(
4162 _: ::fidl_next::Slot<'_, Self>,
4163 _: Self::Constraint,
4164 ) -> Result<(), ::fidl_next::ValidationError> {
4165 Ok(())
4166 }
4167 }
4168
4169 unsafe impl ::fidl_next::Wire for CreateChildArgs<'static> {
4170 type Narrowed<'de> = CreateChildArgs<'de>;
4171
4172 #[inline]
4173 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4174 ::fidl_next::munge!(let Self { table } = out);
4175 ::fidl_next::wire::Table::zero_padding(table);
4176 }
4177 }
4178
4179 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateChildArgs<'de>
4180 where
4181 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4182 ___D: ::fidl_next::fuchsia::HandleDecoder,
4183 {
4184 fn decode(
4185 slot: ::fidl_next::Slot<'_, Self>,
4186 decoder: &mut ___D,
4187 _: (),
4188 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4189 ::fidl_next::munge!(let Self { table } = slot);
4190
4191 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4192 match ordinal {
4193 0 => unsafe { ::core::hint::unreachable_unchecked() },
4194
4195 1 => {
4196 ::fidl_next::wire::Envelope::decode_as::<
4197 ___D,
4198 ::fidl_next::wire::Vector<
4199 'de,
4200 ::fidl_next_fuchsia_process::wire::HandleInfo,
4201 >,
4202 >(slot.as_mut(), decoder, (128, ()))?;
4203
4204 let value = unsafe {
4205 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4206 '_,
4207 ::fidl_next_fuchsia_process::wire::HandleInfo,
4208 >>()
4209 };
4210
4211 if value.len() > 128 {
4212 return Err(::fidl_next::DecodeError::VectorTooLong {
4213 size: value.len() as u64,
4214 limit: 128,
4215 });
4216 }
4217
4218 Ok(())
4219 }
4220
4221 2 => {
4222 ::fidl_next::wire::Envelope::decode_as::<
4223 ___D,
4224 ::fidl_next::wire::Vector<
4225 'de,
4226 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4227 >,
4228 >(slot.as_mut(), decoder, (128, ()))?;
4229
4230 let value = unsafe {
4231 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4232 '_,
4233 ::fidl_next_fuchsia_component_decl::wire::Offer<'_>,
4234 >>()
4235 };
4236
4237 if value.len() > 128 {
4238 return Err(::fidl_next::DecodeError::VectorTooLong {
4239 size: value.len() as u64,
4240 limit: 128,
4241 });
4242 }
4243
4244 Ok(())
4245 }
4246
4247 3 => {
4248 ::fidl_next::wire::Envelope::decode_as::<
4249 ___D,
4250 ::fidl_next::ServerEnd<
4251 crate::Controller,
4252 ::fidl_next::wire::fuchsia::Channel,
4253 >,
4254 >(slot.as_mut(), decoder, ())?;
4255
4256 Ok(())
4257 }
4258
4259 4 => {
4260 ::fidl_next::wire::Envelope::decode_as::<
4261 ___D,
4262 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
4263 >(slot.as_mut(), decoder, ())?;
4264
4265 Ok(())
4266 }
4267
4268 5 => {
4269 ::fidl_next::wire::Envelope::decode_as::<
4270 ___D,
4271 ::fidl_next::wire::fuchsia::EventPair,
4272 >(slot.as_mut(), decoder, ())?;
4273
4274 Ok(())
4275 }
4276
4277 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4278 }
4279 })
4280 }
4281 }
4282
4283 impl<'de> CreateChildArgs<'de> {
4284 pub fn numbered_handles(
4285 &self,
4286 ) -> ::core::option::Option<
4287 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4288 > {
4289 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4290 }
4291
4292 pub fn dynamic_offers(
4293 &self,
4294 ) -> ::core::option::Option<
4295 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4296 > {
4297 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4298 }
4299
4300 pub fn controller(
4301 &self,
4302 ) -> ::core::option::Option<
4303 &::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4304 > {
4305 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4306 }
4307
4308 pub fn dictionary(
4309 &self,
4310 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4311 {
4312 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4313 }
4314
4315 pub fn additional_inputs(
4316 &self,
4317 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4318 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
4319 }
4320 }
4321
4322 impl<'de> ::core::fmt::Debug for CreateChildArgs<'de> {
4323 fn fmt(
4324 &self,
4325 f: &mut ::core::fmt::Formatter<'_>,
4326 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4327 f.debug_struct("CreateChildArgs")
4328 .field("numbered_handles", &self.numbered_handles())
4329 .field("dynamic_offers", &self.dynamic_offers())
4330 .field("controller", &self.controller())
4331 .field("dictionary", &self.dictionary())
4332 .field("additional_inputs", &self.additional_inputs())
4333 .finish()
4334 }
4335 }
4336
4337 impl<'de> ::fidl_next::IntoNatural for CreateChildArgs<'de> {
4338 type Natural = crate::natural::CreateChildArgs;
4339 }
4340
4341 #[repr(C)]
4343 pub struct DebugStartedPayload<'de> {
4344 pub(crate) table: ::fidl_next::wire::Table<'de>,
4345 }
4346
4347 impl<'de> Drop for DebugStartedPayload<'de> {
4348 fn drop(&mut self) {
4349 let _ = self.table.get(1).map(|envelope| unsafe {
4350 envelope.read_unchecked::<::fidl_next::ClientEnd<
4351 ::fidl_next_fuchsia_io::Directory,
4352 ::fidl_next::wire::fuchsia::Channel,
4353 >>()
4354 });
4355
4356 let _ = self.table.get(2).map(|envelope| unsafe {
4357 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4358 });
4359 }
4360 }
4361
4362 impl ::fidl_next::Constrained for DebugStartedPayload<'_> {
4363 type Constraint = ();
4364
4365 fn validate(
4366 _: ::fidl_next::Slot<'_, Self>,
4367 _: Self::Constraint,
4368 ) -> Result<(), ::fidl_next::ValidationError> {
4369 Ok(())
4370 }
4371 }
4372
4373 unsafe impl ::fidl_next::Wire for DebugStartedPayload<'static> {
4374 type Narrowed<'de> = DebugStartedPayload<'de>;
4375
4376 #[inline]
4377 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4378 ::fidl_next::munge!(let Self { table } = out);
4379 ::fidl_next::wire::Table::zero_padding(table);
4380 }
4381 }
4382
4383 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugStartedPayload<'de>
4384 where
4385 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4386 ___D: ::fidl_next::fuchsia::HandleDecoder,
4387 {
4388 fn decode(
4389 slot: ::fidl_next::Slot<'_, Self>,
4390 decoder: &mut ___D,
4391 _: (),
4392 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4393 ::fidl_next::munge!(let Self { table } = slot);
4394
4395 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4396 match ordinal {
4397 0 => unsafe { ::core::hint::unreachable_unchecked() },
4398
4399 1 => {
4400 ::fidl_next::wire::Envelope::decode_as::<
4401 ___D,
4402 ::fidl_next::ClientEnd<
4403 ::fidl_next_fuchsia_io::Directory,
4404 ::fidl_next::wire::fuchsia::Channel,
4405 >,
4406 >(slot.as_mut(), decoder, ())?;
4407
4408 Ok(())
4409 }
4410
4411 2 => {
4412 ::fidl_next::wire::Envelope::decode_as::<
4413 ___D,
4414 ::fidl_next::wire::fuchsia::EventPair,
4415 >(slot.as_mut(), decoder, ())?;
4416
4417 Ok(())
4418 }
4419
4420 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4421 }
4422 })
4423 }
4424 }
4425
4426 impl<'de> DebugStartedPayload<'de> {
4427 pub fn runtime_dir(
4428 &self,
4429 ) -> ::core::option::Option<
4430 &::fidl_next::ClientEnd<
4431 ::fidl_next_fuchsia_io::Directory,
4432 ::fidl_next::wire::fuchsia::Channel,
4433 >,
4434 > {
4435 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4436 }
4437
4438 pub fn break_on_start(
4439 &self,
4440 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4441 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4442 }
4443 }
4444
4445 impl<'de> ::core::fmt::Debug for DebugStartedPayload<'de> {
4446 fn fmt(
4447 &self,
4448 f: &mut ::core::fmt::Formatter<'_>,
4449 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4450 f.debug_struct("DebugStartedPayload")
4451 .field("runtime_dir", &self.runtime_dir())
4452 .field("break_on_start", &self.break_on_start())
4453 .finish()
4454 }
4455 }
4456
4457 impl<'de> ::fidl_next::IntoNatural for DebugStartedPayload<'de> {
4458 type Natural = crate::natural::DebugStartedPayload;
4459 }
4460
4461 #[repr(transparent)]
4463 pub struct EventPayload<'de> {
4464 pub(crate) raw: ::fidl_next::wire::Union,
4465 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4466 }
4467
4468 impl<'de> Drop for EventPayload<'de> {
4469 fn drop(&mut self) {
4470 match self.raw.ordinal() {
4471 1 => {
4472 let _ = unsafe {
4473 self.raw
4474 .get()
4475 .read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4476 };
4477 }
4478
4479 2 => {
4480 let _ = unsafe {
4481 self.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4482 };
4483 }
4484
4485 4 => {
4486 let _ = unsafe {
4487 self.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4488 };
4489 }
4490
4491 5 => {
4492 let _ = unsafe {
4493 self.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4494 };
4495 }
4496
4497 6 => {
4498 let _ = unsafe {
4499 self.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4500 };
4501 }
4502
4503 7 => {
4504 let _ = unsafe {
4505 self.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4506 };
4507 }
4508
4509 8 => {
4510 let _ = unsafe {
4511 self.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4512 };
4513 }
4514
4515 9 => {
4516 let _ = unsafe {
4517 self.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4518 };
4519 }
4520
4521 10 => {
4522 let _ = unsafe {
4523 self.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4524 };
4525 }
4526
4527 _ => (),
4528 }
4529 }
4530 }
4531
4532 impl ::fidl_next::Constrained for EventPayload<'_> {
4533 type Constraint = ();
4534
4535 fn validate(
4536 _: ::fidl_next::Slot<'_, Self>,
4537 _: Self::Constraint,
4538 ) -> Result<(), ::fidl_next::ValidationError> {
4539 Ok(())
4540 }
4541 }
4542
4543 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
4544 type Narrowed<'de> = EventPayload<'de>;
4545
4546 #[inline]
4547 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4548 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4549 ::fidl_next::wire::Union::zero_padding(raw);
4550 }
4551 }
4552
4553 pub mod event_payload {
4554 pub enum Ref<'de> {
4555 CapabilityRequested(&'de crate::wire::CapabilityRequestedPayload<'de>),
4556
4557 Purged(&'de crate::wire::PurgedPayload<'de>),
4558
4559 Discovered(&'de crate::wire::DiscoveredPayload<'de>),
4560
4561 Destroyed(&'de crate::wire::DestroyedPayload<'de>),
4562
4563 Resolved(&'de crate::wire::ResolvedPayload<'de>),
4564
4565 Started(&'de crate::wire::StartedPayload<'de>),
4566
4567 Stopped(&'de crate::wire::StoppedPayload<'de>),
4568
4569 DebugStarted(&'de crate::wire::DebugStartedPayload<'de>),
4570
4571 Unresolved(&'de crate::wire::UnresolvedPayload<'de>),
4572
4573 UnknownOrdinal_(u64),
4574 }
4575 }
4576
4577 impl<'de> EventPayload<'de> {
4578 pub fn as_ref(&self) -> crate::wire::event_payload::Ref<'_> {
4579 match self.raw.ordinal() {
4580 1 => crate::wire::event_payload::Ref::CapabilityRequested(unsafe {
4581 self.raw.get().deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4582 }),
4583
4584 2 => crate::wire::event_payload::Ref::Purged(unsafe {
4585 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>()
4586 }),
4587
4588 4 => crate::wire::event_payload::Ref::Discovered(unsafe {
4589 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>()
4590 }),
4591
4592 5 => crate::wire::event_payload::Ref::Destroyed(unsafe {
4593 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>()
4594 }),
4595
4596 6 => crate::wire::event_payload::Ref::Resolved(unsafe {
4597 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>()
4598 }),
4599
4600 7 => crate::wire::event_payload::Ref::Started(unsafe {
4601 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>()
4602 }),
4603
4604 8 => crate::wire::event_payload::Ref::Stopped(unsafe {
4605 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>()
4606 }),
4607
4608 9 => crate::wire::event_payload::Ref::DebugStarted(unsafe {
4609 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>()
4610 }),
4611
4612 10 => crate::wire::event_payload::Ref::Unresolved(unsafe {
4613 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>()
4614 }),
4615
4616 unknown => crate::wire::event_payload::Ref::UnknownOrdinal_(unknown),
4617 }
4618 }
4619 }
4620
4621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
4622 where
4623 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4624 ___D: ::fidl_next::Decoder<'de>,
4625 ___D: ::fidl_next::fuchsia::HandleDecoder,
4626 {
4627 fn decode(
4628 mut slot: ::fidl_next::Slot<'_, Self>,
4629 decoder: &mut ___D,
4630 _: (),
4631 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4632 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4633 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4634 1 => ::fidl_next::wire::Union::decode_as::<
4635 ___D,
4636 crate::wire::CapabilityRequestedPayload<'de>,
4637 >(raw, decoder, ())?,
4638
4639 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
4640 raw,
4641 decoder,
4642 (),
4643 )?,
4644
4645 4 => ::fidl_next::wire::Union::decode_as::<
4646 ___D,
4647 crate::wire::DiscoveredPayload<'de>,
4648 >(raw, decoder, ())?,
4649
4650 5 => {
4651 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
4652 raw,
4653 decoder,
4654 (),
4655 )?
4656 }
4657
4658 6 => {
4659 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
4660 raw,
4661 decoder,
4662 (),
4663 )?
4664 }
4665
4666 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
4667 raw,
4668 decoder,
4669 (),
4670 )?,
4671
4672 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
4673 raw,
4674 decoder,
4675 (),
4676 )?,
4677
4678 9 => ::fidl_next::wire::Union::decode_as::<
4679 ___D,
4680 crate::wire::DebugStartedPayload<'de>,
4681 >(raw, decoder, ())?,
4682
4683 10 => ::fidl_next::wire::Union::decode_as::<
4684 ___D,
4685 crate::wire::UnresolvedPayload<'de>,
4686 >(raw, decoder, ())?,
4687
4688 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4689 }
4690
4691 Ok(())
4692 }
4693 }
4694
4695 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
4696 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4697 match self.raw.ordinal() {
4698 1 => unsafe {
4699 self.raw
4700 .get()
4701 .deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4702 .fmt(f)
4703 },
4704 2 => unsafe {
4705 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>().fmt(f)
4706 },
4707 4 => unsafe {
4708 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>().fmt(f)
4709 },
4710 5 => unsafe {
4711 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>().fmt(f)
4712 },
4713 6 => unsafe {
4714 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>().fmt(f)
4715 },
4716 7 => unsafe {
4717 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>().fmt(f)
4718 },
4719 8 => unsafe {
4720 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>().fmt(f)
4721 },
4722 9 => unsafe {
4723 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>().fmt(f)
4724 },
4725 10 => unsafe {
4726 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>().fmt(f)
4727 },
4728 _ => unsafe { ::core::hint::unreachable_unchecked() },
4729 }
4730 }
4731 }
4732
4733 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
4734 type Natural = crate::natural::EventPayload;
4735 }
4736
4737 #[repr(C)]
4739 pub struct Event<'de> {
4740 pub(crate) table: ::fidl_next::wire::Table<'de>,
4741 }
4742
4743 impl<'de> Drop for Event<'de> {
4744 fn drop(&mut self) {
4745 let _ = self.table.get(1).map(|envelope| unsafe {
4746 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
4747 });
4748
4749 let _ = self.table.get(2).map(|envelope| unsafe {
4750 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
4751 });
4752 }
4753 }
4754
4755 impl ::fidl_next::Constrained for Event<'_> {
4756 type Constraint = ();
4757
4758 fn validate(
4759 _: ::fidl_next::Slot<'_, Self>,
4760 _: Self::Constraint,
4761 ) -> Result<(), ::fidl_next::ValidationError> {
4762 Ok(())
4763 }
4764 }
4765
4766 unsafe impl ::fidl_next::Wire for Event<'static> {
4767 type Narrowed<'de> = Event<'de>;
4768
4769 #[inline]
4770 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4771 ::fidl_next::munge!(let Self { table } = out);
4772 ::fidl_next::wire::Table::zero_padding(table);
4773 }
4774 }
4775
4776 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Event<'de>
4777 where
4778 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4779 ___D: ::fidl_next::fuchsia::HandleDecoder,
4780 {
4781 fn decode(
4782 slot: ::fidl_next::Slot<'_, Self>,
4783 decoder: &mut ___D,
4784 _: (),
4785 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4786 ::fidl_next::munge!(let Self { table } = slot);
4787
4788 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4789 match ordinal {
4790 0 => unsafe { ::core::hint::unreachable_unchecked() },
4791
4792 1 => {
4793 ::fidl_next::wire::Envelope::decode_as::<
4794 ___D,
4795 crate::wire::EventHeader<'de>,
4796 >(slot.as_mut(), decoder, ())?;
4797
4798 Ok(())
4799 }
4800
4801 2 => {
4802 ::fidl_next::wire::Envelope::decode_as::<
4803 ___D,
4804 crate::wire::EventPayload<'de>,
4805 >(slot.as_mut(), decoder, ())?;
4806
4807 Ok(())
4808 }
4809
4810 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4811 }
4812 })
4813 }
4814 }
4815
4816 impl<'de> Event<'de> {
4817 pub fn header(&self) -> ::core::option::Option<&crate::wire::EventHeader<'de>> {
4818 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4819 }
4820
4821 pub fn payload(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
4822 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4823 }
4824 }
4825
4826 impl<'de> ::core::fmt::Debug for Event<'de> {
4827 fn fmt(
4828 &self,
4829 f: &mut ::core::fmt::Formatter<'_>,
4830 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4831 f.debug_struct("Event")
4832 .field("header", &self.header())
4833 .field("payload", &self.payload())
4834 .finish()
4835 }
4836 }
4837
4838 impl<'de> ::fidl_next::IntoNatural for Event<'de> {
4839 type Natural = crate::natural::Event;
4840 }
4841
4842 #[derive(Debug)]
4844 #[repr(C)]
4845 pub struct EventStreamGetNextResponse<'de> {
4846 pub events: ::fidl_next::wire::Vector<'de, crate::wire::Event<'de>>,
4847 }
4848
4849 static_assertions::const_assert_eq!(std::mem::size_of::<EventStreamGetNextResponse<'_>>(), 16);
4850 static_assertions::const_assert_eq!(std::mem::align_of::<EventStreamGetNextResponse<'_>>(), 8);
4851
4852 static_assertions::const_assert_eq!(
4853 std::mem::offset_of!(EventStreamGetNextResponse<'_>, events),
4854 0
4855 );
4856
4857 impl ::fidl_next::Constrained for EventStreamGetNextResponse<'_> {
4858 type Constraint = ();
4859
4860 fn validate(
4861 _: ::fidl_next::Slot<'_, Self>,
4862 _: Self::Constraint,
4863 ) -> Result<(), ::fidl_next::ValidationError> {
4864 Ok(())
4865 }
4866 }
4867
4868 unsafe impl ::fidl_next::Wire for EventStreamGetNextResponse<'static> {
4869 type Narrowed<'de> = EventStreamGetNextResponse<'de>;
4870
4871 #[inline]
4872 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4873 ::fidl_next::munge! {
4874 let Self {
4875 events,
4876
4877 } = &mut *out_;
4878 }
4879
4880 ::fidl_next::Wire::zero_padding(events);
4881 }
4882 }
4883
4884 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStreamGetNextResponse<'de>
4885 where
4886 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4887 ___D: ::fidl_next::Decoder<'de>,
4888 ___D: ::fidl_next::fuchsia::HandleDecoder,
4889 {
4890 fn decode(
4891 slot_: ::fidl_next::Slot<'_, Self>,
4892 decoder_: &mut ___D,
4893 _: (),
4894 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4895 ::fidl_next::munge! {
4896 let Self {
4897 mut events,
4898
4899 } = slot_;
4900 }
4901
4902 let _field = events.as_mut();
4903 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
4904 ::fidl_next::Decode::decode(events.as_mut(), decoder_, (4294967295, ()))?;
4905
4906 Ok(())
4907 }
4908 }
4909
4910 impl<'de> ::fidl_next::IntoNatural for EventStreamGetNextResponse<'de> {
4911 type Natural = crate::natural::EventStreamGetNextResponse;
4912 }
4913
4914 #[derive(Debug)]
4916 #[repr(C)]
4917 pub struct IntrospectorGetMonikerRequest {
4918 pub component_instance: ::fidl_next::wire::fuchsia::Event,
4919 }
4920
4921 static_assertions::const_assert_eq!(std::mem::size_of::<IntrospectorGetMonikerRequest>(), 4);
4922 static_assertions::const_assert_eq!(std::mem::align_of::<IntrospectorGetMonikerRequest>(), 4);
4923
4924 static_assertions::const_assert_eq!(
4925 std::mem::offset_of!(IntrospectorGetMonikerRequest, component_instance),
4926 0
4927 );
4928
4929 impl ::fidl_next::Constrained for IntrospectorGetMonikerRequest {
4930 type Constraint = ();
4931
4932 fn validate(
4933 _: ::fidl_next::Slot<'_, Self>,
4934 _: Self::Constraint,
4935 ) -> Result<(), ::fidl_next::ValidationError> {
4936 Ok(())
4937 }
4938 }
4939
4940 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerRequest {
4941 type Narrowed<'de> = IntrospectorGetMonikerRequest;
4942
4943 #[inline]
4944 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4945 ::fidl_next::munge! {
4946 let Self {
4947 component_instance,
4948
4949 } = &mut *out_;
4950 }
4951
4952 ::fidl_next::Wire::zero_padding(component_instance);
4953 }
4954 }
4955
4956 unsafe impl<___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerRequest
4957 where
4958 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4959 ___D: ::fidl_next::fuchsia::HandleDecoder,
4960 {
4961 fn decode(
4962 slot_: ::fidl_next::Slot<'_, Self>,
4963 decoder_: &mut ___D,
4964 _: (),
4965 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4966 ::fidl_next::munge! {
4967 let Self {
4968 mut component_instance,
4969
4970 } = slot_;
4971 }
4972
4973 let _field = component_instance.as_mut();
4974
4975 ::fidl_next::Decode::decode(component_instance.as_mut(), decoder_, ())?;
4976
4977 Ok(())
4978 }
4979 }
4980
4981 impl ::fidl_next::IntoNatural for IntrospectorGetMonikerRequest {
4982 type Natural = crate::natural::IntrospectorGetMonikerRequest;
4983 }
4984
4985 #[derive(Debug)]
4987 #[repr(C)]
4988 pub struct NamespaceInputEntry<'de> {
4989 pub path: ::fidl_next::wire::String<'de>,
4990
4991 pub dictionary: ::fidl_next::ClientEnd<
4992 ::fidl_next_fuchsia_component_sandbox::Dictionary,
4993 ::fidl_next::wire::fuchsia::Channel,
4994 >,
4995 }
4996
4997 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry<'_>>(), 24);
4998 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry<'_>>(), 8);
4999
5000 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry<'_>, path), 0);
5001
5002 static_assertions::const_assert_eq!(
5003 std::mem::offset_of!(NamespaceInputEntry<'_>, dictionary),
5004 16
5005 );
5006
5007 impl ::fidl_next::Constrained for NamespaceInputEntry<'_> {
5008 type Constraint = ();
5009
5010 fn validate(
5011 _: ::fidl_next::Slot<'_, Self>,
5012 _: Self::Constraint,
5013 ) -> Result<(), ::fidl_next::ValidationError> {
5014 Ok(())
5015 }
5016 }
5017
5018 unsafe impl ::fidl_next::Wire for NamespaceInputEntry<'static> {
5019 type Narrowed<'de> = NamespaceInputEntry<'de>;
5020
5021 #[inline]
5022 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5023 ::fidl_next::munge! {
5024 let Self {
5025 path,
5026 dictionary,
5027
5028 } = &mut *out_;
5029 }
5030
5031 ::fidl_next::Wire::zero_padding(path);
5032
5033 ::fidl_next::Wire::zero_padding(dictionary);
5034
5035 unsafe {
5036 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5037 }
5038 }
5039 }
5040
5041 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry<'de>
5042 where
5043 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5044 ___D: ::fidl_next::Decoder<'de>,
5045 ___D: ::fidl_next::fuchsia::HandleDecoder,
5046 {
5047 fn decode(
5048 slot_: ::fidl_next::Slot<'_, Self>,
5049 decoder_: &mut ___D,
5050 _: (),
5051 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5052 if slot_.as_bytes()[20..24] != [0u8; 4] {
5053 return Err(::fidl_next::DecodeError::InvalidPadding);
5054 }
5055
5056 ::fidl_next::munge! {
5057 let Self {
5058 mut path,
5059 mut dictionary,
5060
5061 } = slot_;
5062 }
5063
5064 let _field = path.as_mut();
5065 ::fidl_next::Constrained::validate(_field, 4095)?;
5066 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5067
5068 let path = unsafe { path.deref_unchecked() };
5069
5070 if path.len() > 4095 {
5071 return Err(::fidl_next::DecodeError::VectorTooLong {
5072 size: path.len() as u64,
5073 limit: 4095,
5074 });
5075 }
5076
5077 let _field = dictionary.as_mut();
5078
5079 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5080
5081 Ok(())
5082 }
5083 }
5084
5085 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry<'de> {
5086 type Natural = crate::natural::NamespaceInputEntry;
5087 }
5088
5089 #[derive(Debug)]
5091 #[repr(C)]
5092 pub struct NamespaceCreateRequest<'de> {
5093 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry<'de>>,
5094 }
5095
5096 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateRequest<'_>>(), 16);
5097 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateRequest<'_>>(), 8);
5098
5099 static_assertions::const_assert_eq!(
5100 std::mem::offset_of!(NamespaceCreateRequest<'_>, entries),
5101 0
5102 );
5103
5104 impl ::fidl_next::Constrained for NamespaceCreateRequest<'_> {
5105 type Constraint = ();
5106
5107 fn validate(
5108 _: ::fidl_next::Slot<'_, Self>,
5109 _: Self::Constraint,
5110 ) -> Result<(), ::fidl_next::ValidationError> {
5111 Ok(())
5112 }
5113 }
5114
5115 unsafe impl ::fidl_next::Wire for NamespaceCreateRequest<'static> {
5116 type Narrowed<'de> = NamespaceCreateRequest<'de>;
5117
5118 #[inline]
5119 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5120 ::fidl_next::munge! {
5121 let Self {
5122 entries,
5123
5124 } = &mut *out_;
5125 }
5126
5127 ::fidl_next::Wire::zero_padding(entries);
5128 }
5129 }
5130
5131 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateRequest<'de>
5132 where
5133 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5134 ___D: ::fidl_next::Decoder<'de>,
5135 ___D: ::fidl_next::fuchsia::HandleDecoder,
5136 {
5137 fn decode(
5138 slot_: ::fidl_next::Slot<'_, Self>,
5139 decoder_: &mut ___D,
5140 _: (),
5141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5142 ::fidl_next::munge! {
5143 let Self {
5144 mut entries,
5145
5146 } = slot_;
5147 }
5148
5149 let _field = entries.as_mut();
5150 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5151 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5152
5153 Ok(())
5154 }
5155 }
5156
5157 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateRequest<'de> {
5158 type Natural = crate::natural::NamespaceCreateRequest;
5159 }
5160
5161 #[derive(Debug)]
5163 #[repr(C)]
5164 pub struct NamespaceInputEntry2<'de> {
5165 pub path: ::fidl_next::wire::String<'de>,
5166
5167 pub capability: ::fidl_next::wire::fuchsia::EventPair,
5168 }
5169
5170 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry2<'_>>(), 24);
5171 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry2<'_>>(), 8);
5172
5173 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry2<'_>, path), 0);
5174
5175 static_assertions::const_assert_eq!(
5176 std::mem::offset_of!(NamespaceInputEntry2<'_>, capability),
5177 16
5178 );
5179
5180 impl ::fidl_next::Constrained for NamespaceInputEntry2<'_> {
5181 type Constraint = ();
5182
5183 fn validate(
5184 _: ::fidl_next::Slot<'_, Self>,
5185 _: Self::Constraint,
5186 ) -> Result<(), ::fidl_next::ValidationError> {
5187 Ok(())
5188 }
5189 }
5190
5191 unsafe impl ::fidl_next::Wire for NamespaceInputEntry2<'static> {
5192 type Narrowed<'de> = NamespaceInputEntry2<'de>;
5193
5194 #[inline]
5195 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5196 ::fidl_next::munge! {
5197 let Self {
5198 path,
5199 capability,
5200
5201 } = &mut *out_;
5202 }
5203
5204 ::fidl_next::Wire::zero_padding(path);
5205
5206 ::fidl_next::Wire::zero_padding(capability);
5207
5208 unsafe {
5209 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5210 }
5211 }
5212 }
5213
5214 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry2<'de>
5215 where
5216 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5217 ___D: ::fidl_next::Decoder<'de>,
5218 ___D: ::fidl_next::fuchsia::HandleDecoder,
5219 {
5220 fn decode(
5221 slot_: ::fidl_next::Slot<'_, Self>,
5222 decoder_: &mut ___D,
5223 _: (),
5224 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5225 if slot_.as_bytes()[20..24] != [0u8; 4] {
5226 return Err(::fidl_next::DecodeError::InvalidPadding);
5227 }
5228
5229 ::fidl_next::munge! {
5230 let Self {
5231 mut path,
5232 mut capability,
5233
5234 } = slot_;
5235 }
5236
5237 let _field = path.as_mut();
5238 ::fidl_next::Constrained::validate(_field, 4095)?;
5239 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5240
5241 let path = unsafe { path.deref_unchecked() };
5242
5243 if path.len() > 4095 {
5244 return Err(::fidl_next::DecodeError::VectorTooLong {
5245 size: path.len() as u64,
5246 limit: 4095,
5247 });
5248 }
5249
5250 let _field = capability.as_mut();
5251
5252 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5253
5254 Ok(())
5255 }
5256 }
5257
5258 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry2<'de> {
5259 type Natural = crate::natural::NamespaceInputEntry2;
5260 }
5261
5262 #[derive(Debug)]
5264 #[repr(C)]
5265 pub struct NamespaceCreate2Request<'de> {
5266 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry2<'de>>,
5267 }
5268
5269 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Request<'_>>(), 16);
5270 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Request<'_>>(), 8);
5271
5272 static_assertions::const_assert_eq!(
5273 std::mem::offset_of!(NamespaceCreate2Request<'_>, entries),
5274 0
5275 );
5276
5277 impl ::fidl_next::Constrained for NamespaceCreate2Request<'_> {
5278 type Constraint = ();
5279
5280 fn validate(
5281 _: ::fidl_next::Slot<'_, Self>,
5282 _: Self::Constraint,
5283 ) -> Result<(), ::fidl_next::ValidationError> {
5284 Ok(())
5285 }
5286 }
5287
5288 unsafe impl ::fidl_next::Wire for NamespaceCreate2Request<'static> {
5289 type Narrowed<'de> = NamespaceCreate2Request<'de>;
5290
5291 #[inline]
5292 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5293 ::fidl_next::munge! {
5294 let Self {
5295 entries,
5296
5297 } = &mut *out_;
5298 }
5299
5300 ::fidl_next::Wire::zero_padding(entries);
5301 }
5302 }
5303
5304 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Request<'de>
5305 where
5306 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5307 ___D: ::fidl_next::Decoder<'de>,
5308 ___D: ::fidl_next::fuchsia::HandleDecoder,
5309 {
5310 fn decode(
5311 slot_: ::fidl_next::Slot<'_, Self>,
5312 decoder_: &mut ___D,
5313 _: (),
5314 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5315 ::fidl_next::munge! {
5316 let Self {
5317 mut entries,
5318
5319 } = slot_;
5320 }
5321
5322 let _field = entries.as_mut();
5323 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5324 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5325
5326 Ok(())
5327 }
5328 }
5329
5330 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Request<'de> {
5331 type Natural = crate::natural::NamespaceCreate2Request;
5332 }
5333
5334 #[derive(Debug)]
5336 #[repr(C)]
5337 pub struct NamespaceCreateResponse<'de> {
5338 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5339 }
5340
5341 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateResponse<'_>>(), 16);
5342 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateResponse<'_>>(), 8);
5343
5344 static_assertions::const_assert_eq!(
5345 std::mem::offset_of!(NamespaceCreateResponse<'_>, entries),
5346 0
5347 );
5348
5349 impl ::fidl_next::Constrained for NamespaceCreateResponse<'_> {
5350 type Constraint = ();
5351
5352 fn validate(
5353 _: ::fidl_next::Slot<'_, Self>,
5354 _: Self::Constraint,
5355 ) -> Result<(), ::fidl_next::ValidationError> {
5356 Ok(())
5357 }
5358 }
5359
5360 unsafe impl ::fidl_next::Wire for NamespaceCreateResponse<'static> {
5361 type Narrowed<'de> = NamespaceCreateResponse<'de>;
5362
5363 #[inline]
5364 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5365 ::fidl_next::munge! {
5366 let Self {
5367 entries,
5368
5369 } = &mut *out_;
5370 }
5371
5372 ::fidl_next::Wire::zero_padding(entries);
5373 }
5374 }
5375
5376 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateResponse<'de>
5377 where
5378 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5379 ___D: ::fidl_next::Decoder<'de>,
5380 ___D: ::fidl_next::fuchsia::HandleDecoder,
5381 {
5382 fn decode(
5383 slot_: ::fidl_next::Slot<'_, Self>,
5384 decoder_: &mut ___D,
5385 _: (),
5386 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5387 ::fidl_next::munge! {
5388 let Self {
5389 mut entries,
5390
5391 } = slot_;
5392 }
5393
5394 let _field = entries.as_mut();
5395 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5396 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5397
5398 Ok(())
5399 }
5400 }
5401
5402 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateResponse<'de> {
5403 type Natural = crate::natural::NamespaceCreateResponse;
5404 }
5405
5406 #[derive(Debug)]
5408 #[repr(C)]
5409 pub struct NamespaceCreate2Response<'de> {
5410 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5411 }
5412
5413 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Response<'_>>(), 16);
5414 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Response<'_>>(), 8);
5415
5416 static_assertions::const_assert_eq!(
5417 std::mem::offset_of!(NamespaceCreate2Response<'_>, entries),
5418 0
5419 );
5420
5421 impl ::fidl_next::Constrained for NamespaceCreate2Response<'_> {
5422 type Constraint = ();
5423
5424 fn validate(
5425 _: ::fidl_next::Slot<'_, Self>,
5426 _: Self::Constraint,
5427 ) -> Result<(), ::fidl_next::ValidationError> {
5428 Ok(())
5429 }
5430 }
5431
5432 unsafe impl ::fidl_next::Wire for NamespaceCreate2Response<'static> {
5433 type Narrowed<'de> = NamespaceCreate2Response<'de>;
5434
5435 #[inline]
5436 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5437 ::fidl_next::munge! {
5438 let Self {
5439 entries,
5440
5441 } = &mut *out_;
5442 }
5443
5444 ::fidl_next::Wire::zero_padding(entries);
5445 }
5446 }
5447
5448 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Response<'de>
5449 where
5450 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5451 ___D: ::fidl_next::Decoder<'de>,
5452 ___D: ::fidl_next::fuchsia::HandleDecoder,
5453 {
5454 fn decode(
5455 slot_: ::fidl_next::Slot<'_, Self>,
5456 decoder_: &mut ___D,
5457 _: (),
5458 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5459 ::fidl_next::munge! {
5460 let Self {
5461 mut entries,
5462
5463 } = slot_;
5464 }
5465
5466 let _field = entries.as_mut();
5467 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5468 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5469
5470 Ok(())
5471 }
5472 }
5473
5474 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Response<'de> {
5475 type Natural = crate::natural::NamespaceCreate2Response;
5476 }
5477
5478 #[derive(Debug)]
5480 #[repr(C)]
5481 pub struct RealmListChildrenRequest<'de> {
5482 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
5483
5484 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
5485 }
5486
5487 static_assertions::const_assert_eq!(std::mem::size_of::<RealmListChildrenRequest<'_>>(), 24);
5488 static_assertions::const_assert_eq!(std::mem::align_of::<RealmListChildrenRequest<'_>>(), 8);
5489
5490 static_assertions::const_assert_eq!(
5491 std::mem::offset_of!(RealmListChildrenRequest<'_>, collection),
5492 0
5493 );
5494
5495 static_assertions::const_assert_eq!(
5496 std::mem::offset_of!(RealmListChildrenRequest<'_>, iter),
5497 16
5498 );
5499
5500 impl ::fidl_next::Constrained for RealmListChildrenRequest<'_> {
5501 type Constraint = ();
5502
5503 fn validate(
5504 _: ::fidl_next::Slot<'_, Self>,
5505 _: Self::Constraint,
5506 ) -> Result<(), ::fidl_next::ValidationError> {
5507 Ok(())
5508 }
5509 }
5510
5511 unsafe impl ::fidl_next::Wire for RealmListChildrenRequest<'static> {
5512 type Narrowed<'de> = RealmListChildrenRequest<'de>;
5513
5514 #[inline]
5515 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5516 ::fidl_next::munge! {
5517 let Self {
5518 collection,
5519 iter,
5520
5521 } = &mut *out_;
5522 }
5523
5524 ::fidl_next::Wire::zero_padding(collection);
5525
5526 ::fidl_next::Wire::zero_padding(iter);
5527
5528 unsafe {
5529 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5530 }
5531 }
5532 }
5533
5534 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmListChildrenRequest<'de>
5535 where
5536 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5537 ___D: ::fidl_next::Decoder<'de>,
5538 ___D: ::fidl_next::fuchsia::HandleDecoder,
5539 {
5540 fn decode(
5541 slot_: ::fidl_next::Slot<'_, Self>,
5542 decoder_: &mut ___D,
5543 _: (),
5544 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5545 if slot_.as_bytes()[20..24] != [0u8; 4] {
5546 return Err(::fidl_next::DecodeError::InvalidPadding);
5547 }
5548
5549 ::fidl_next::munge! {
5550 let Self {
5551 mut collection,
5552 mut iter,
5553
5554 } = slot_;
5555 }
5556
5557 let _field = collection.as_mut();
5558
5559 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
5560
5561 let _field = iter.as_mut();
5562
5563 ::fidl_next::Decode::decode(iter.as_mut(), decoder_, ())?;
5564
5565 Ok(())
5566 }
5567 }
5568
5569 impl<'de> ::fidl_next::IntoNatural for RealmListChildrenRequest<'de> {
5570 type Natural = crate::natural::RealmListChildrenRequest;
5571 }
5572
5573 #[derive(Debug)]
5575 #[repr(C)]
5576 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5577 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5578 }
5579
5580 static_assertions::const_assert_eq!(
5581 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5582 32
5583 );
5584 static_assertions::const_assert_eq!(
5585 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5586 8
5587 );
5588
5589 static_assertions::const_assert_eq!(
5590 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedRequest<'_>, child),
5591 0
5592 );
5593
5594 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedRequest<'_> {
5595 type Constraint = ();
5596
5597 fn validate(
5598 _: ::fidl_next::Slot<'_, Self>,
5599 _: Self::Constraint,
5600 ) -> Result<(), ::fidl_next::ValidationError> {
5601 Ok(())
5602 }
5603 }
5604
5605 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedRequest<'static> {
5606 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedRequest<'de>;
5607
5608 #[inline]
5609 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5610 ::fidl_next::munge! {
5611 let Self {
5612 child,
5613
5614 } = &mut *out_;
5615 }
5616
5617 ::fidl_next::Wire::zero_padding(child);
5618 }
5619 }
5620
5621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5622 for RealmGetChildOutputDictionaryDeprecatedRequest<'de>
5623 where
5624 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5625 ___D: ::fidl_next::Decoder<'de>,
5626 ___D: ::fidl_next::fuchsia::HandleDecoder,
5627 {
5628 fn decode(
5629 slot_: ::fidl_next::Slot<'_, Self>,
5630 decoder_: &mut ___D,
5631 _: (),
5632 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5633 ::fidl_next::munge! {
5634 let Self {
5635 mut child,
5636
5637 } = slot_;
5638 }
5639
5640 let _field = child.as_mut();
5641
5642 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5643
5644 Ok(())
5645 }
5646 }
5647
5648 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5649 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
5650 }
5651
5652 #[derive(Debug)]
5654 #[repr(C)]
5655 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
5656 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
5657 }
5658
5659 static_assertions::const_assert_eq!(
5660 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5661 4
5662 );
5663 static_assertions::const_assert_eq!(
5664 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5665 4
5666 );
5667
5668 static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedResponse, dictionary),
5670 0
5671 );
5672
5673 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedResponse {
5674 type Constraint = ();
5675
5676 fn validate(
5677 _: ::fidl_next::Slot<'_, Self>,
5678 _: Self::Constraint,
5679 ) -> Result<(), ::fidl_next::ValidationError> {
5680 Ok(())
5681 }
5682 }
5683
5684 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedResponse {
5685 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedResponse;
5686
5687 #[inline]
5688 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5689 ::fidl_next::munge! {
5690 let Self {
5691 dictionary,
5692
5693 } = &mut *out_;
5694 }
5695
5696 ::fidl_next::Wire::zero_padding(dictionary);
5697 }
5698 }
5699
5700 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryDeprecatedResponse
5701 where
5702 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5703 ___D: ::fidl_next::fuchsia::HandleDecoder,
5704 {
5705 fn decode(
5706 slot_: ::fidl_next::Slot<'_, Self>,
5707 decoder_: &mut ___D,
5708 _: (),
5709 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5710 ::fidl_next::munge! {
5711 let Self {
5712 mut dictionary,
5713
5714 } = slot_;
5715 }
5716
5717 let _field = dictionary.as_mut();
5718
5719 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5720
5721 Ok(())
5722 }
5723 }
5724
5725 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedResponse {
5726 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
5727 }
5728
5729 #[derive(Debug)]
5731 #[repr(C)]
5732 pub struct RealmGetChildOutputDictionaryRequest<'de> {
5733 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5734 }
5735
5736 static_assertions::const_assert_eq!(
5737 std::mem::size_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5738 32
5739 );
5740 static_assertions::const_assert_eq!(
5741 std::mem::align_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5742 8
5743 );
5744
5745 static_assertions::const_assert_eq!(
5746 std::mem::offset_of!(RealmGetChildOutputDictionaryRequest<'_>, child),
5747 0
5748 );
5749
5750 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryRequest<'_> {
5751 type Constraint = ();
5752
5753 fn validate(
5754 _: ::fidl_next::Slot<'_, Self>,
5755 _: Self::Constraint,
5756 ) -> Result<(), ::fidl_next::ValidationError> {
5757 Ok(())
5758 }
5759 }
5760
5761 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryRequest<'static> {
5762 type Narrowed<'de> = RealmGetChildOutputDictionaryRequest<'de>;
5763
5764 #[inline]
5765 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5766 ::fidl_next::munge! {
5767 let Self {
5768 child,
5769
5770 } = &mut *out_;
5771 }
5772
5773 ::fidl_next::Wire::zero_padding(child);
5774 }
5775 }
5776
5777 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryRequest<'de>
5778 where
5779 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5780 ___D: ::fidl_next::Decoder<'de>,
5781 ___D: ::fidl_next::fuchsia::HandleDecoder,
5782 {
5783 fn decode(
5784 slot_: ::fidl_next::Slot<'_, Self>,
5785 decoder_: &mut ___D,
5786 _: (),
5787 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5788 ::fidl_next::munge! {
5789 let Self {
5790 mut child,
5791
5792 } = slot_;
5793 }
5794
5795 let _field = child.as_mut();
5796
5797 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5798
5799 Ok(())
5800 }
5801 }
5802
5803 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryRequest<'de> {
5804 type Natural = crate::natural::RealmGetChildOutputDictionaryRequest;
5805 }
5806
5807 #[derive(Debug)]
5809 #[repr(C)]
5810 pub struct RealmGetChildOutputDictionaryResponse {
5811 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
5812 }
5813
5814 static_assertions::const_assert_eq!(
5815 std::mem::size_of::<RealmGetChildOutputDictionaryResponse>(),
5816 4
5817 );
5818 static_assertions::const_assert_eq!(
5819 std::mem::align_of::<RealmGetChildOutputDictionaryResponse>(),
5820 4
5821 );
5822
5823 static_assertions::const_assert_eq!(
5824 std::mem::offset_of!(RealmGetChildOutputDictionaryResponse, dictionary),
5825 0
5826 );
5827
5828 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryResponse {
5829 type Constraint = ();
5830
5831 fn validate(
5832 _: ::fidl_next::Slot<'_, Self>,
5833 _: Self::Constraint,
5834 ) -> Result<(), ::fidl_next::ValidationError> {
5835 Ok(())
5836 }
5837 }
5838
5839 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryResponse {
5840 type Narrowed<'de> = RealmGetChildOutputDictionaryResponse;
5841
5842 #[inline]
5843 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5844 ::fidl_next::munge! {
5845 let Self {
5846 dictionary,
5847
5848 } = &mut *out_;
5849 }
5850
5851 ::fidl_next::Wire::zero_padding(dictionary);
5852 }
5853 }
5854
5855 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryResponse
5856 where
5857 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5858 ___D: ::fidl_next::fuchsia::HandleDecoder,
5859 {
5860 fn decode(
5861 slot_: ::fidl_next::Slot<'_, Self>,
5862 decoder_: &mut ___D,
5863 _: (),
5864 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5865 ::fidl_next::munge! {
5866 let Self {
5867 mut dictionary,
5868
5869 } = slot_;
5870 }
5871
5872 let _field = dictionary.as_mut();
5873
5874 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5875
5876 Ok(())
5877 }
5878 }
5879
5880 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryResponse {
5881 type Natural = crate::natural::RealmGetChildOutputDictionaryResponse;
5882 }
5883
5884 #[derive(Debug)]
5886 #[repr(C)]
5887 pub struct RealmOpenControllerRequest<'de> {
5888 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5889
5890 pub controller:
5891 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
5892 }
5893
5894 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenControllerRequest<'_>>(), 40);
5895 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenControllerRequest<'_>>(), 8);
5896
5897 static_assertions::const_assert_eq!(
5898 std::mem::offset_of!(RealmOpenControllerRequest<'_>, child),
5899 0
5900 );
5901
5902 static_assertions::const_assert_eq!(
5903 std::mem::offset_of!(RealmOpenControllerRequest<'_>, controller),
5904 32
5905 );
5906
5907 impl ::fidl_next::Constrained for RealmOpenControllerRequest<'_> {
5908 type Constraint = ();
5909
5910 fn validate(
5911 _: ::fidl_next::Slot<'_, Self>,
5912 _: Self::Constraint,
5913 ) -> Result<(), ::fidl_next::ValidationError> {
5914 Ok(())
5915 }
5916 }
5917
5918 unsafe impl ::fidl_next::Wire for RealmOpenControllerRequest<'static> {
5919 type Narrowed<'de> = RealmOpenControllerRequest<'de>;
5920
5921 #[inline]
5922 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5923 ::fidl_next::munge! {
5924 let Self {
5925 child,
5926 controller,
5927
5928 } = &mut *out_;
5929 }
5930
5931 ::fidl_next::Wire::zero_padding(child);
5932
5933 ::fidl_next::Wire::zero_padding(controller);
5934
5935 unsafe {
5936 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
5937 }
5938 }
5939 }
5940
5941 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenControllerRequest<'de>
5942 where
5943 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5944 ___D: ::fidl_next::Decoder<'de>,
5945 ___D: ::fidl_next::fuchsia::HandleDecoder,
5946 {
5947 fn decode(
5948 slot_: ::fidl_next::Slot<'_, Self>,
5949 decoder_: &mut ___D,
5950 _: (),
5951 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5952 if slot_.as_bytes()[36..40] != [0u8; 4] {
5953 return Err(::fidl_next::DecodeError::InvalidPadding);
5954 }
5955
5956 ::fidl_next::munge! {
5957 let Self {
5958 mut child,
5959 mut controller,
5960
5961 } = slot_;
5962 }
5963
5964 let _field = child.as_mut();
5965
5966 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5967
5968 let _field = controller.as_mut();
5969
5970 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
5971
5972 Ok(())
5973 }
5974 }
5975
5976 impl<'de> ::fidl_next::IntoNatural for RealmOpenControllerRequest<'de> {
5977 type Natural = crate::natural::RealmOpenControllerRequest;
5978 }
5979
5980 #[derive(Debug)]
5982 #[repr(C)]
5983 pub struct RealmOpenExposedDirRequest<'de> {
5984 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5985
5986 pub exposed_dir: ::fidl_next::ServerEnd<
5987 ::fidl_next_fuchsia_io::Directory,
5988 ::fidl_next::wire::fuchsia::Channel,
5989 >,
5990 }
5991
5992 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenExposedDirRequest<'_>>(), 40);
5993 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenExposedDirRequest<'_>>(), 8);
5994
5995 static_assertions::const_assert_eq!(
5996 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, child),
5997 0
5998 );
5999
6000 static_assertions::const_assert_eq!(
6001 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, exposed_dir),
6002 32
6003 );
6004
6005 impl ::fidl_next::Constrained for RealmOpenExposedDirRequest<'_> {
6006 type Constraint = ();
6007
6008 fn validate(
6009 _: ::fidl_next::Slot<'_, Self>,
6010 _: Self::Constraint,
6011 ) -> Result<(), ::fidl_next::ValidationError> {
6012 Ok(())
6013 }
6014 }
6015
6016 unsafe impl ::fidl_next::Wire for RealmOpenExposedDirRequest<'static> {
6017 type Narrowed<'de> = RealmOpenExposedDirRequest<'de>;
6018
6019 #[inline]
6020 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6021 ::fidl_next::munge! {
6022 let Self {
6023 child,
6024 exposed_dir,
6025
6026 } = &mut *out_;
6027 }
6028
6029 ::fidl_next::Wire::zero_padding(child);
6030
6031 ::fidl_next::Wire::zero_padding(exposed_dir);
6032
6033 unsafe {
6034 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6035 }
6036 }
6037 }
6038
6039 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenExposedDirRequest<'de>
6040 where
6041 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6042 ___D: ::fidl_next::Decoder<'de>,
6043 ___D: ::fidl_next::fuchsia::HandleDecoder,
6044 {
6045 fn decode(
6046 slot_: ::fidl_next::Slot<'_, Self>,
6047 decoder_: &mut ___D,
6048 _: (),
6049 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6050 if slot_.as_bytes()[36..40] != [0u8; 4] {
6051 return Err(::fidl_next::DecodeError::InvalidPadding);
6052 }
6053
6054 ::fidl_next::munge! {
6055 let Self {
6056 mut child,
6057 mut exposed_dir,
6058
6059 } = slot_;
6060 }
6061
6062 let _field = child.as_mut();
6063
6064 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6065
6066 let _field = exposed_dir.as_mut();
6067
6068 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
6069
6070 Ok(())
6071 }
6072 }
6073
6074 impl<'de> ::fidl_next::IntoNatural for RealmOpenExposedDirRequest<'de> {
6075 type Natural = crate::natural::RealmOpenExposedDirRequest;
6076 }
6077
6078 #[derive(Debug)]
6080 #[repr(C)]
6081 pub struct RealmCreateChildRequest<'de> {
6082 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
6083
6084 pub decl: ::fidl_next_fuchsia_component_decl::wire::Child<'de>,
6085
6086 pub args: crate::wire::CreateChildArgs<'de>,
6087 }
6088
6089 static_assertions::const_assert_eq!(std::mem::size_of::<RealmCreateChildRequest<'_>>(), 48);
6090 static_assertions::const_assert_eq!(std::mem::align_of::<RealmCreateChildRequest<'_>>(), 8);
6091
6092 static_assertions::const_assert_eq!(
6093 std::mem::offset_of!(RealmCreateChildRequest<'_>, collection),
6094 0
6095 );
6096
6097 static_assertions::const_assert_eq!(
6098 std::mem::offset_of!(RealmCreateChildRequest<'_>, decl),
6099 16
6100 );
6101
6102 static_assertions::const_assert_eq!(
6103 std::mem::offset_of!(RealmCreateChildRequest<'_>, args),
6104 32
6105 );
6106
6107 impl ::fidl_next::Constrained for RealmCreateChildRequest<'_> {
6108 type Constraint = ();
6109
6110 fn validate(
6111 _: ::fidl_next::Slot<'_, Self>,
6112 _: Self::Constraint,
6113 ) -> Result<(), ::fidl_next::ValidationError> {
6114 Ok(())
6115 }
6116 }
6117
6118 unsafe impl ::fidl_next::Wire for RealmCreateChildRequest<'static> {
6119 type Narrowed<'de> = RealmCreateChildRequest<'de>;
6120
6121 #[inline]
6122 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6123 ::fidl_next::munge! {
6124 let Self {
6125 collection,
6126 decl,
6127 args,
6128
6129 } = &mut *out_;
6130 }
6131
6132 ::fidl_next::Wire::zero_padding(collection);
6133
6134 ::fidl_next::Wire::zero_padding(decl);
6135
6136 ::fidl_next::Wire::zero_padding(args);
6137 }
6138 }
6139
6140 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmCreateChildRequest<'de>
6141 where
6142 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6143 ___D: ::fidl_next::Decoder<'de>,
6144 ___D: ::fidl_next::fuchsia::HandleDecoder,
6145 {
6146 fn decode(
6147 slot_: ::fidl_next::Slot<'_, Self>,
6148 decoder_: &mut ___D,
6149 _: (),
6150 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6151 ::fidl_next::munge! {
6152 let Self {
6153 mut collection,
6154 mut decl,
6155 mut args,
6156
6157 } = slot_;
6158 }
6159
6160 let _field = collection.as_mut();
6161
6162 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
6163
6164 let _field = decl.as_mut();
6165
6166 ::fidl_next::Decode::decode(decl.as_mut(), decoder_, ())?;
6167
6168 let _field = args.as_mut();
6169
6170 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
6171
6172 Ok(())
6173 }
6174 }
6175
6176 impl<'de> ::fidl_next::IntoNatural for RealmCreateChildRequest<'de> {
6177 type Natural = crate::natural::RealmCreateChildRequest;
6178 }
6179
6180 #[derive(Debug)]
6182 #[repr(C)]
6183 pub struct RealmGetResolvedInfoResponse<'de> {
6184 pub resolved_info: ::fidl_next_fuchsia_component_resolution::wire::Component<'de>,
6185 }
6186
6187 static_assertions::const_assert_eq!(
6188 std::mem::size_of::<RealmGetResolvedInfoResponse<'_>>(),
6189 16
6190 );
6191 static_assertions::const_assert_eq!(
6192 std::mem::align_of::<RealmGetResolvedInfoResponse<'_>>(),
6193 8
6194 );
6195
6196 static_assertions::const_assert_eq!(
6197 std::mem::offset_of!(RealmGetResolvedInfoResponse<'_>, resolved_info),
6198 0
6199 );
6200
6201 impl ::fidl_next::Constrained for RealmGetResolvedInfoResponse<'_> {
6202 type Constraint = ();
6203
6204 fn validate(
6205 _: ::fidl_next::Slot<'_, Self>,
6206 _: Self::Constraint,
6207 ) -> Result<(), ::fidl_next::ValidationError> {
6208 Ok(())
6209 }
6210 }
6211
6212 unsafe impl ::fidl_next::Wire for RealmGetResolvedInfoResponse<'static> {
6213 type Narrowed<'de> = RealmGetResolvedInfoResponse<'de>;
6214
6215 #[inline]
6216 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6217 ::fidl_next::munge! {
6218 let Self {
6219 resolved_info,
6220
6221 } = &mut *out_;
6222 }
6223
6224 ::fidl_next::Wire::zero_padding(resolved_info);
6225 }
6226 }
6227
6228 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetResolvedInfoResponse<'de>
6229 where
6230 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6231 ___D: ::fidl_next::Decoder<'de>,
6232 ___D: ::fidl_next::fuchsia::HandleDecoder,
6233 {
6234 fn decode(
6235 slot_: ::fidl_next::Slot<'_, Self>,
6236 decoder_: &mut ___D,
6237 _: (),
6238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6239 ::fidl_next::munge! {
6240 let Self {
6241 mut resolved_info,
6242
6243 } = slot_;
6244 }
6245
6246 let _field = resolved_info.as_mut();
6247
6248 ::fidl_next::Decode::decode(resolved_info.as_mut(), decoder_, ())?;
6249
6250 Ok(())
6251 }
6252 }
6253
6254 impl<'de> ::fidl_next::IntoNatural for RealmGetResolvedInfoResponse<'de> {
6255 type Natural = crate::natural::RealmGetResolvedInfoResponse;
6256 }
6257
6258 #[derive(Debug)]
6260 #[repr(C)]
6261 pub struct StorageAdminListStorageInRealmRequest<'de> {
6262 pub relative_moniker: ::fidl_next::wire::String<'de>,
6263
6264 pub iterator:
6265 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
6266 }
6267
6268 static_assertions::const_assert_eq!(
6269 std::mem::size_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6270 24
6271 );
6272 static_assertions::const_assert_eq!(
6273 std::mem::align_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6274 8
6275 );
6276
6277 static_assertions::const_assert_eq!(
6278 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, relative_moniker),
6279 0
6280 );
6281
6282 static_assertions::const_assert_eq!(
6283 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, iterator),
6284 16
6285 );
6286
6287 impl ::fidl_next::Constrained for StorageAdminListStorageInRealmRequest<'_> {
6288 type Constraint = ();
6289
6290 fn validate(
6291 _: ::fidl_next::Slot<'_, Self>,
6292 _: Self::Constraint,
6293 ) -> Result<(), ::fidl_next::ValidationError> {
6294 Ok(())
6295 }
6296 }
6297
6298 unsafe impl ::fidl_next::Wire for StorageAdminListStorageInRealmRequest<'static> {
6299 type Narrowed<'de> = StorageAdminListStorageInRealmRequest<'de>;
6300
6301 #[inline]
6302 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6303 ::fidl_next::munge! {
6304 let Self {
6305 relative_moniker,
6306 iterator,
6307
6308 } = &mut *out_;
6309 }
6310
6311 ::fidl_next::Wire::zero_padding(relative_moniker);
6312
6313 ::fidl_next::Wire::zero_padding(iterator);
6314
6315 unsafe {
6316 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6317 }
6318 }
6319 }
6320
6321 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminListStorageInRealmRequest<'de>
6322 where
6323 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6324 ___D: ::fidl_next::Decoder<'de>,
6325 ___D: ::fidl_next::fuchsia::HandleDecoder,
6326 {
6327 fn decode(
6328 slot_: ::fidl_next::Slot<'_, Self>,
6329 decoder_: &mut ___D,
6330 _: (),
6331 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6332 if slot_.as_bytes()[20..24] != [0u8; 4] {
6333 return Err(::fidl_next::DecodeError::InvalidPadding);
6334 }
6335
6336 ::fidl_next::munge! {
6337 let Self {
6338 mut relative_moniker,
6339 mut iterator,
6340
6341 } = slot_;
6342 }
6343
6344 let _field = relative_moniker.as_mut();
6345 ::fidl_next::Constrained::validate(_field, 4096)?;
6346 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6347
6348 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6349
6350 if relative_moniker.len() > 4096 {
6351 return Err(::fidl_next::DecodeError::VectorTooLong {
6352 size: relative_moniker.len() as u64,
6353 limit: 4096,
6354 });
6355 }
6356
6357 let _field = iterator.as_mut();
6358
6359 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
6360
6361 Ok(())
6362 }
6363 }
6364
6365 impl<'de> ::fidl_next::IntoNatural for StorageAdminListStorageInRealmRequest<'de> {
6366 type Natural = crate::natural::StorageAdminListStorageInRealmRequest;
6367 }
6368
6369 #[derive(Debug)]
6371 #[repr(C)]
6372 pub struct StorageAdminOpenStorageRequest<'de> {
6373 pub relative_moniker: ::fidl_next::wire::String<'de>,
6374
6375 pub object: ::fidl_next::ServerEnd<
6376 ::fidl_next_fuchsia_io::Node,
6377 ::fidl_next::wire::fuchsia::Channel,
6378 >,
6379 }
6380
6381 static_assertions::const_assert_eq!(
6382 std::mem::size_of::<StorageAdminOpenStorageRequest<'_>>(),
6383 24
6384 );
6385 static_assertions::const_assert_eq!(
6386 std::mem::align_of::<StorageAdminOpenStorageRequest<'_>>(),
6387 8
6388 );
6389
6390 static_assertions::const_assert_eq!(
6391 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, relative_moniker),
6392 0
6393 );
6394
6395 static_assertions::const_assert_eq!(
6396 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, object),
6397 16
6398 );
6399
6400 impl ::fidl_next::Constrained for StorageAdminOpenStorageRequest<'_> {
6401 type Constraint = ();
6402
6403 fn validate(
6404 _: ::fidl_next::Slot<'_, Self>,
6405 _: Self::Constraint,
6406 ) -> Result<(), ::fidl_next::ValidationError> {
6407 Ok(())
6408 }
6409 }
6410
6411 unsafe impl ::fidl_next::Wire for StorageAdminOpenStorageRequest<'static> {
6412 type Narrowed<'de> = StorageAdminOpenStorageRequest<'de>;
6413
6414 #[inline]
6415 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6416 ::fidl_next::munge! {
6417 let Self {
6418 relative_moniker,
6419 object,
6420
6421 } = &mut *out_;
6422 }
6423
6424 ::fidl_next::Wire::zero_padding(relative_moniker);
6425
6426 ::fidl_next::Wire::zero_padding(object);
6427
6428 unsafe {
6429 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6430 }
6431 }
6432 }
6433
6434 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminOpenStorageRequest<'de>
6435 where
6436 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6437 ___D: ::fidl_next::Decoder<'de>,
6438 ___D: ::fidl_next::fuchsia::HandleDecoder,
6439 {
6440 fn decode(
6441 slot_: ::fidl_next::Slot<'_, Self>,
6442 decoder_: &mut ___D,
6443 _: (),
6444 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6445 if slot_.as_bytes()[20..24] != [0u8; 4] {
6446 return Err(::fidl_next::DecodeError::InvalidPadding);
6447 }
6448
6449 ::fidl_next::munge! {
6450 let Self {
6451 mut relative_moniker,
6452 mut object,
6453
6454 } = slot_;
6455 }
6456
6457 let _field = relative_moniker.as_mut();
6458 ::fidl_next::Constrained::validate(_field, 4096)?;
6459 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6460
6461 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6462
6463 if relative_moniker.len() > 4096 {
6464 return Err(::fidl_next::DecodeError::VectorTooLong {
6465 size: relative_moniker.len() as u64,
6466 limit: 4096,
6467 });
6468 }
6469
6470 let _field = object.as_mut();
6471
6472 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6473
6474 Ok(())
6475 }
6476 }
6477
6478 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenStorageRequest<'de> {
6479 type Natural = crate::natural::StorageAdminOpenStorageRequest;
6480 }
6481
6482 #[derive(Debug)]
6484 #[repr(C)]
6485 pub struct StorageAdminOpenComponentStorageByIdRequest<'de> {
6486 pub id: ::fidl_next::wire::String<'de>,
6487
6488 pub object: ::fidl_next::ServerEnd<
6489 ::fidl_next_fuchsia_io::Node,
6490 ::fidl_next::wire::fuchsia::Channel,
6491 >,
6492 }
6493
6494 static_assertions::const_assert_eq!(
6495 std::mem::size_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6496 24
6497 );
6498 static_assertions::const_assert_eq!(
6499 std::mem::align_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6500 8
6501 );
6502
6503 static_assertions::const_assert_eq!(
6504 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, id),
6505 0
6506 );
6507
6508 static_assertions::const_assert_eq!(
6509 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, object),
6510 16
6511 );
6512
6513 impl ::fidl_next::Constrained for StorageAdminOpenComponentStorageByIdRequest<'_> {
6514 type Constraint = ();
6515
6516 fn validate(
6517 _: ::fidl_next::Slot<'_, Self>,
6518 _: Self::Constraint,
6519 ) -> Result<(), ::fidl_next::ValidationError> {
6520 Ok(())
6521 }
6522 }
6523
6524 unsafe impl ::fidl_next::Wire for StorageAdminOpenComponentStorageByIdRequest<'static> {
6525 type Narrowed<'de> = StorageAdminOpenComponentStorageByIdRequest<'de>;
6526
6527 #[inline]
6528 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6529 ::fidl_next::munge! {
6530 let Self {
6531 id,
6532 object,
6533
6534 } = &mut *out_;
6535 }
6536
6537 ::fidl_next::Wire::zero_padding(id);
6538
6539 ::fidl_next::Wire::zero_padding(object);
6540
6541 unsafe {
6542 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6543 }
6544 }
6545 }
6546
6547 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6548 for StorageAdminOpenComponentStorageByIdRequest<'de>
6549 where
6550 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6551 ___D: ::fidl_next::Decoder<'de>,
6552 ___D: ::fidl_next::fuchsia::HandleDecoder,
6553 {
6554 fn decode(
6555 slot_: ::fidl_next::Slot<'_, Self>,
6556 decoder_: &mut ___D,
6557 _: (),
6558 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6559 if slot_.as_bytes()[20..24] != [0u8; 4] {
6560 return Err(::fidl_next::DecodeError::InvalidPadding);
6561 }
6562
6563 ::fidl_next::munge! {
6564 let Self {
6565 mut id,
6566 mut object,
6567
6568 } = slot_;
6569 }
6570
6571 let _field = id.as_mut();
6572 ::fidl_next::Constrained::validate(_field, 64)?;
6573 ::fidl_next::Decode::decode(id.as_mut(), decoder_, 64)?;
6574
6575 let id = unsafe { id.deref_unchecked() };
6576
6577 if id.len() > 64 {
6578 return Err(::fidl_next::DecodeError::VectorTooLong {
6579 size: id.len() as u64,
6580 limit: 64,
6581 });
6582 }
6583
6584 let _field = object.as_mut();
6585
6586 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6587
6588 Ok(())
6589 }
6590 }
6591
6592 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenComponentStorageByIdRequest<'de> {
6593 type Natural = crate::natural::StorageAdminOpenComponentStorageByIdRequest;
6594 }
6595}
6596
6597pub mod wire_optional {
6598
6599 pub use fidl_next_common_fuchsia_component::wire_optional::*;
6600
6601 #[repr(transparent)]
6602 pub struct EventPayload<'de> {
6603 pub(crate) raw: ::fidl_next::wire::Union,
6604 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6605 }
6606
6607 impl ::fidl_next::Constrained for EventPayload<'_> {
6608 type Constraint = ();
6609
6610 fn validate(
6611 _: ::fidl_next::Slot<'_, Self>,
6612 _: Self::Constraint,
6613 ) -> Result<(), ::fidl_next::ValidationError> {
6614 Ok(())
6615 }
6616 }
6617
6618 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
6619 type Narrowed<'de> = EventPayload<'de>;
6620
6621 #[inline]
6622 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6623 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6624 ::fidl_next::wire::Union::zero_padding(raw);
6625 }
6626 }
6627
6628 impl<'de> EventPayload<'de> {
6629 pub fn is_some(&self) -> bool {
6630 self.raw.is_some()
6631 }
6632
6633 pub fn is_none(&self) -> bool {
6634 self.raw.is_none()
6635 }
6636
6637 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
6638 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6639 }
6640
6641 pub fn into_option(self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
6642 if self.is_some() {
6643 Some(crate::wire::EventPayload {
6644 raw: self.raw,
6645 _phantom: ::core::marker::PhantomData,
6646 })
6647 } else {
6648 None
6649 }
6650 }
6651 }
6652
6653 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
6654 where
6655 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6656 ___D: ::fidl_next::Decoder<'de>,
6657 ___D: ::fidl_next::fuchsia::HandleDecoder,
6658 {
6659 fn decode(
6660 mut slot: ::fidl_next::Slot<'_, Self>,
6661 decoder: &mut ___D,
6662 _: (),
6663 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6664 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6665 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6666 1 => ::fidl_next::wire::Union::decode_as::<
6667 ___D,
6668 crate::wire::CapabilityRequestedPayload<'de>,
6669 >(raw, decoder, ())?,
6670
6671 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
6672 raw,
6673 decoder,
6674 (),
6675 )?,
6676
6677 4 => ::fidl_next::wire::Union::decode_as::<
6678 ___D,
6679 crate::wire::DiscoveredPayload<'de>,
6680 >(raw, decoder, ())?,
6681
6682 5 => {
6683 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
6684 raw,
6685 decoder,
6686 (),
6687 )?
6688 }
6689
6690 6 => {
6691 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
6692 raw,
6693 decoder,
6694 (),
6695 )?
6696 }
6697
6698 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
6699 raw,
6700 decoder,
6701 (),
6702 )?,
6703
6704 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
6705 raw,
6706 decoder,
6707 (),
6708 )?,
6709
6710 9 => ::fidl_next::wire::Union::decode_as::<
6711 ___D,
6712 crate::wire::DebugStartedPayload<'de>,
6713 >(raw, decoder, ())?,
6714
6715 10 => ::fidl_next::wire::Union::decode_as::<
6716 ___D,
6717 crate::wire::UnresolvedPayload<'de>,
6718 >(raw, decoder, ())?,
6719
6720 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
6721 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
6722 }
6723
6724 Ok(())
6725 }
6726 }
6727
6728 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
6729 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6730 self.as_ref().fmt(f)
6731 }
6732 }
6733
6734 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
6735 type Natural = ::core::option::Option<crate::natural::EventPayload>;
6736 }
6737}
6738
6739pub mod generic {
6740
6741 pub use fidl_next_common_fuchsia_component::generic::*;
6742
6743 pub struct ControllerIsStartedResponse<T0> {
6745 pub is_started: T0,
6746 }
6747
6748 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6749 for ControllerIsStartedResponse<T0>
6750 where
6751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6752 ___E: ::fidl_next::fuchsia::HandleEncoder,
6753 T0: ::fidl_next::Encode<bool, ___E>,
6754 {
6755 #[inline]
6756 fn encode(
6757 self,
6758 encoder_: &mut ___E,
6759 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6760 _: (),
6761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6762 ::fidl_next::munge! {
6763 let crate::wire::ControllerIsStartedResponse {
6764 is_started,
6765
6766 } = out_;
6767 }
6768
6769 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
6770
6771 Ok(())
6772 }
6773 }
6774
6775 pub struct ControllerGetExposedDictionaryResponse<T0> {
6777 pub dictionary: T0,
6778 }
6779
6780 unsafe impl<___E, T0>
6781 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
6782 for ControllerGetExposedDictionaryResponse<T0>
6783 where
6784 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6785 ___E: ::fidl_next::fuchsia::HandleEncoder,
6786 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
6787 {
6788 #[inline]
6789 fn encode(
6790 self,
6791 encoder_: &mut ___E,
6792 out_: &mut ::core::mem::MaybeUninit<
6793 crate::wire::ControllerGetExposedDictionaryResponse,
6794 >,
6795 _: (),
6796 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6797 ::fidl_next::munge! {
6798 let crate::wire::ControllerGetExposedDictionaryResponse {
6799 dictionary,
6800
6801 } = out_;
6802 }
6803
6804 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6805
6806 Ok(())
6807 }
6808 }
6809
6810 pub struct ControllerGetOutputDictionaryResponse<T0> {
6812 pub dictionary: T0,
6813 }
6814
6815 unsafe impl<___E, T0>
6816 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
6817 for ControllerGetOutputDictionaryResponse<T0>
6818 where
6819 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6820 ___E: ::fidl_next::fuchsia::HandleEncoder,
6821 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
6822 {
6823 #[inline]
6824 fn encode(
6825 self,
6826 encoder_: &mut ___E,
6827 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
6828 _: (),
6829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6830 ::fidl_next::munge! {
6831 let crate::wire::ControllerGetOutputDictionaryResponse {
6832 dictionary,
6833
6834 } = out_;
6835 }
6836
6837 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6838
6839 Ok(())
6840 }
6841 }
6842
6843 pub struct ControllerStartRequest<T0, T1> {
6845 pub args: T0,
6846
6847 pub execution_controller: T1,
6848 }
6849
6850 unsafe impl<___E, T0, T1>
6851 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
6852 for ControllerStartRequest<T0, T1>
6853 where
6854 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6855 ___E: ::fidl_next::Encoder,
6856 ___E: ::fidl_next::fuchsia::HandleEncoder,
6857 T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
6858 T1: ::fidl_next::Encode<
6859 ::fidl_next::ServerEnd<
6860 crate::ExecutionController,
6861 ::fidl_next::wire::fuchsia::Channel,
6862 >,
6863 ___E,
6864 >,
6865 {
6866 #[inline]
6867 fn encode(
6868 self,
6869 encoder_: &mut ___E,
6870 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
6871 _: (),
6872 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6873 ::fidl_next::munge! {
6874 let crate::wire::ControllerStartRequest {
6875 args,
6876 execution_controller,
6877
6878 } = out_;
6879 }
6880
6881 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
6882
6883 ::fidl_next::Encode::encode(
6884 self.execution_controller,
6885 encoder_,
6886 execution_controller,
6887 (),
6888 )?;
6889
6890 Ok(())
6891 }
6892 }
6893
6894 pub struct ControllerOpenExposedDirRequest<T0> {
6896 pub exposed_dir: T0,
6897 }
6898
6899 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
6900 for ControllerOpenExposedDirRequest<T0>
6901 where
6902 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6903 ___E: ::fidl_next::fuchsia::HandleEncoder,
6904 T0: ::fidl_next::Encode<
6905 ::fidl_next::ServerEnd<
6906 ::fidl_next_fuchsia_io::Directory,
6907 ::fidl_next::wire::fuchsia::Channel,
6908 >,
6909 ___E,
6910 >,
6911 {
6912 #[inline]
6913 fn encode(
6914 self,
6915 encoder_: &mut ___E,
6916 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
6917 _: (),
6918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6919 ::fidl_next::munge! {
6920 let crate::wire::ControllerOpenExposedDirRequest {
6921 exposed_dir,
6922
6923 } = out_;
6924 }
6925
6926 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
6927
6928 Ok(())
6929 }
6930 }
6931
6932 pub struct EventStreamGetNextResponse<T0> {
6934 pub events: T0,
6935 }
6936
6937 unsafe impl<___E, T0>
6938 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
6939 for EventStreamGetNextResponse<T0>
6940 where
6941 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6942 ___E: ::fidl_next::Encoder,
6943 ___E: ::fidl_next::fuchsia::HandleEncoder,
6944 T0: ::fidl_next::Encode<
6945 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
6946 ___E,
6947 >,
6948 {
6949 #[inline]
6950 fn encode(
6951 self,
6952 encoder_: &mut ___E,
6953 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
6954 _: (),
6955 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6956 ::fidl_next::munge! {
6957 let crate::wire::EventStreamGetNextResponse {
6958 events,
6959
6960 } = out_;
6961 }
6962
6963 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
6964
6965 Ok(())
6966 }
6967 }
6968
6969 pub struct IntrospectorGetMonikerRequest<T0> {
6971 pub component_instance: T0,
6972 }
6973
6974 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
6975 for IntrospectorGetMonikerRequest<T0>
6976 where
6977 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6978 ___E: ::fidl_next::fuchsia::HandleEncoder,
6979 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
6980 {
6981 #[inline]
6982 fn encode(
6983 self,
6984 encoder_: &mut ___E,
6985 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
6986 _: (),
6987 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6988 ::fidl_next::munge! {
6989 let crate::wire::IntrospectorGetMonikerRequest {
6990 component_instance,
6991
6992 } = out_;
6993 }
6994
6995 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
6996
6997 Ok(())
6998 }
6999 }
7000
7001 pub struct NamespaceInputEntry<T0, T1> {
7003 pub path: T0,
7004
7005 pub dictionary: T1,
7006 }
7007
7008 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7009 for NamespaceInputEntry<T0, T1>
7010 where
7011 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7012 ___E: ::fidl_next::Encoder,
7013 ___E: ::fidl_next::fuchsia::HandleEncoder,
7014 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7015 T1: ::fidl_next::Encode<
7016 ::fidl_next::ClientEnd<
7017 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7018 ::fidl_next::wire::fuchsia::Channel,
7019 >,
7020 ___E,
7021 >,
7022 {
7023 #[inline]
7024 fn encode(
7025 self,
7026 encoder_: &mut ___E,
7027 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7028 _: (),
7029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7030 ::fidl_next::munge! {
7031 let crate::wire::NamespaceInputEntry {
7032 path,
7033 dictionary,
7034
7035 } = out_;
7036 }
7037
7038 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7039
7040 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7041
7042 Ok(())
7043 }
7044 }
7045
7046 pub struct NamespaceCreateRequest<T0> {
7048 pub entries: T0,
7049 }
7050
7051 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7052 for NamespaceCreateRequest<T0>
7053 where
7054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7055 ___E: ::fidl_next::Encoder,
7056 ___E: ::fidl_next::fuchsia::HandleEncoder,
7057 T0: ::fidl_next::Encode<
7058 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7059 ___E,
7060 >,
7061 {
7062 #[inline]
7063 fn encode(
7064 self,
7065 encoder_: &mut ___E,
7066 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7067 _: (),
7068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7069 ::fidl_next::munge! {
7070 let crate::wire::NamespaceCreateRequest {
7071 entries,
7072
7073 } = out_;
7074 }
7075
7076 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7077
7078 Ok(())
7079 }
7080 }
7081
7082 pub struct NamespaceInputEntry2<T0, T1> {
7084 pub path: T0,
7085
7086 pub capability: T1,
7087 }
7088
7089 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7090 for NamespaceInputEntry2<T0, T1>
7091 where
7092 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7093 ___E: ::fidl_next::Encoder,
7094 ___E: ::fidl_next::fuchsia::HandleEncoder,
7095 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7096 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7097 {
7098 #[inline]
7099 fn encode(
7100 self,
7101 encoder_: &mut ___E,
7102 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7103 _: (),
7104 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7105 ::fidl_next::munge! {
7106 let crate::wire::NamespaceInputEntry2 {
7107 path,
7108 capability,
7109
7110 } = out_;
7111 }
7112
7113 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7114
7115 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7116
7117 Ok(())
7118 }
7119 }
7120
7121 pub struct NamespaceCreate2Request<T0> {
7123 pub entries: T0,
7124 }
7125
7126 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7127 for NamespaceCreate2Request<T0>
7128 where
7129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7130 ___E: ::fidl_next::Encoder,
7131 ___E: ::fidl_next::fuchsia::HandleEncoder,
7132 T0: ::fidl_next::Encode<
7133 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7134 ___E,
7135 >,
7136 {
7137 #[inline]
7138 fn encode(
7139 self,
7140 encoder_: &mut ___E,
7141 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7142 _: (),
7143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7144 ::fidl_next::munge! {
7145 let crate::wire::NamespaceCreate2Request {
7146 entries,
7147
7148 } = out_;
7149 }
7150
7151 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7152
7153 Ok(())
7154 }
7155 }
7156
7157 pub struct NamespaceCreateResponse<T0> {
7159 pub entries: T0,
7160 }
7161
7162 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7163 for NamespaceCreateResponse<T0>
7164 where
7165 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7166 ___E: ::fidl_next::Encoder,
7167 ___E: ::fidl_next::fuchsia::HandleEncoder,
7168 T0: ::fidl_next::Encode<
7169 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7170 ___E,
7171 >,
7172 {
7173 #[inline]
7174 fn encode(
7175 self,
7176 encoder_: &mut ___E,
7177 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7178 _: (),
7179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7180 ::fidl_next::munge! {
7181 let crate::wire::NamespaceCreateResponse {
7182 entries,
7183
7184 } = out_;
7185 }
7186
7187 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7188
7189 Ok(())
7190 }
7191 }
7192
7193 pub struct NamespaceCreate2Response<T0> {
7195 pub entries: T0,
7196 }
7197
7198 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7199 for NamespaceCreate2Response<T0>
7200 where
7201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7202 ___E: ::fidl_next::Encoder,
7203 ___E: ::fidl_next::fuchsia::HandleEncoder,
7204 T0: ::fidl_next::Encode<
7205 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7206 ___E,
7207 >,
7208 {
7209 #[inline]
7210 fn encode(
7211 self,
7212 encoder_: &mut ___E,
7213 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7214 _: (),
7215 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7216 ::fidl_next::munge! {
7217 let crate::wire::NamespaceCreate2Response {
7218 entries,
7219
7220 } = out_;
7221 }
7222
7223 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7224
7225 Ok(())
7226 }
7227 }
7228
7229 pub struct RealmListChildrenRequest<T0, T1> {
7231 pub collection: T0,
7232
7233 pub iter: T1,
7234 }
7235
7236 unsafe impl<___E, T0, T1>
7237 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7238 for RealmListChildrenRequest<T0, T1>
7239 where
7240 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7241 ___E: ::fidl_next::Encoder,
7242 ___E: ::fidl_next::fuchsia::HandleEncoder,
7243 T0: ::fidl_next::Encode<
7244 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7245 ___E,
7246 >,
7247 T1: ::fidl_next::Encode<
7248 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7249 ___E,
7250 >,
7251 {
7252 #[inline]
7253 fn encode(
7254 self,
7255 encoder_: &mut ___E,
7256 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7257 _: (),
7258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7259 ::fidl_next::munge! {
7260 let crate::wire::RealmListChildrenRequest {
7261 collection,
7262 iter,
7263
7264 } = out_;
7265 }
7266
7267 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7268
7269 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
7270
7271 Ok(())
7272 }
7273 }
7274
7275 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<T0> {
7277 pub child: T0,
7278 }
7279
7280 unsafe impl<___E, T0>
7281 ::fidl_next::Encode<
7282 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7283 ___E,
7284 > for RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7285 where
7286 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7287 ___E: ::fidl_next::Encoder,
7288 ___E: ::fidl_next::fuchsia::HandleEncoder,
7289 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7290 {
7291 #[inline]
7292 fn encode(
7293 self,
7294 encoder_: &mut ___E,
7295 out_: &mut ::core::mem::MaybeUninit<
7296 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7297 >,
7298 _: (),
7299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7300 ::fidl_next::munge! {
7301 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7302 child,
7303
7304 } = out_;
7305 }
7306
7307 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7308
7309 Ok(())
7310 }
7311 }
7312
7313 pub struct RealmGetChildOutputDictionaryDeprecatedResponse<T0> {
7315 pub dictionary: T0,
7316 }
7317
7318 unsafe impl<___E, T0>
7319 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
7320 for RealmGetChildOutputDictionaryDeprecatedResponse<T0>
7321 where
7322 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7323 ___E: ::fidl_next::fuchsia::HandleEncoder,
7324 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
7325 {
7326 #[inline]
7327 fn encode(
7328 self,
7329 encoder_: &mut ___E,
7330 out_: &mut ::core::mem::MaybeUninit<
7331 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
7332 >,
7333 _: (),
7334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7335 ::fidl_next::munge! {
7336 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
7337 dictionary,
7338
7339 } = out_;
7340 }
7341
7342 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7343
7344 Ok(())
7345 }
7346 }
7347
7348 pub struct RealmGetChildOutputDictionaryRequest<T0> {
7350 pub child: T0,
7351 }
7352
7353 unsafe impl<___E, T0>
7354 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
7355 for RealmGetChildOutputDictionaryRequest<T0>
7356 where
7357 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7358 ___E: ::fidl_next::Encoder,
7359 ___E: ::fidl_next::fuchsia::HandleEncoder,
7360 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7361 {
7362 #[inline]
7363 fn encode(
7364 self,
7365 encoder_: &mut ___E,
7366 out_: &mut ::core::mem::MaybeUninit<
7367 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
7368 >,
7369 _: (),
7370 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7371 ::fidl_next::munge! {
7372 let crate::wire::RealmGetChildOutputDictionaryRequest {
7373 child,
7374
7375 } = out_;
7376 }
7377
7378 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7379
7380 Ok(())
7381 }
7382 }
7383
7384 pub struct RealmGetChildOutputDictionaryResponse<T0> {
7386 pub dictionary: T0,
7387 }
7388
7389 unsafe impl<___E, T0>
7390 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
7391 for RealmGetChildOutputDictionaryResponse<T0>
7392 where
7393 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7394 ___E: ::fidl_next::fuchsia::HandleEncoder,
7395 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7396 {
7397 #[inline]
7398 fn encode(
7399 self,
7400 encoder_: &mut ___E,
7401 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
7402 _: (),
7403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7404 ::fidl_next::munge! {
7405 let crate::wire::RealmGetChildOutputDictionaryResponse {
7406 dictionary,
7407
7408 } = out_;
7409 }
7410
7411 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7412
7413 Ok(())
7414 }
7415 }
7416
7417 pub struct RealmOpenControllerRequest<T0, T1> {
7419 pub child: T0,
7420
7421 pub controller: T1,
7422 }
7423
7424 unsafe impl<___E, T0, T1>
7425 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
7426 for RealmOpenControllerRequest<T0, T1>
7427 where
7428 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7429 ___E: ::fidl_next::Encoder,
7430 ___E: ::fidl_next::fuchsia::HandleEncoder,
7431 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7432 T1: ::fidl_next::Encode<
7433 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
7434 ___E,
7435 >,
7436 {
7437 #[inline]
7438 fn encode(
7439 self,
7440 encoder_: &mut ___E,
7441 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
7442 _: (),
7443 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7444 ::fidl_next::munge! {
7445 let crate::wire::RealmOpenControllerRequest {
7446 child,
7447 controller,
7448
7449 } = out_;
7450 }
7451
7452 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7453
7454 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
7455
7456 Ok(())
7457 }
7458 }
7459
7460 pub struct RealmOpenExposedDirRequest<T0, T1> {
7462 pub child: T0,
7463
7464 pub exposed_dir: T1,
7465 }
7466
7467 unsafe impl<___E, T0, T1>
7468 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
7469 for RealmOpenExposedDirRequest<T0, T1>
7470 where
7471 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7472 ___E: ::fidl_next::Encoder,
7473 ___E: ::fidl_next::fuchsia::HandleEncoder,
7474 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7475 T1: ::fidl_next::Encode<
7476 ::fidl_next::ServerEnd<
7477 ::fidl_next_fuchsia_io::Directory,
7478 ::fidl_next::wire::fuchsia::Channel,
7479 >,
7480 ___E,
7481 >,
7482 {
7483 #[inline]
7484 fn encode(
7485 self,
7486 encoder_: &mut ___E,
7487 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
7488 _: (),
7489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7490 ::fidl_next::munge! {
7491 let crate::wire::RealmOpenExposedDirRequest {
7492 child,
7493 exposed_dir,
7494
7495 } = out_;
7496 }
7497
7498 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7499
7500 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7501
7502 Ok(())
7503 }
7504 }
7505
7506 pub struct RealmCreateChildRequest<T0, T1, T2> {
7508 pub collection: T0,
7509
7510 pub decl: T1,
7511
7512 pub args: T2,
7513 }
7514
7515 unsafe impl<___E, T0, T1, T2>
7516 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
7517 for RealmCreateChildRequest<T0, T1, T2>
7518 where
7519 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7520 ___E: ::fidl_next::Encoder,
7521 ___E: ::fidl_next::fuchsia::HandleEncoder,
7522 T0: ::fidl_next::Encode<
7523 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7524 ___E,
7525 >,
7526 T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
7527 T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
7528 {
7529 #[inline]
7530 fn encode(
7531 self,
7532 encoder_: &mut ___E,
7533 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
7534 _: (),
7535 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7536 ::fidl_next::munge! {
7537 let crate::wire::RealmCreateChildRequest {
7538 collection,
7539 decl,
7540 args,
7541
7542 } = out_;
7543 }
7544
7545 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7546
7547 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
7548
7549 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7550
7551 Ok(())
7552 }
7553 }
7554
7555 pub struct RealmGetResolvedInfoResponse<T0> {
7557 pub resolved_info: T0,
7558 }
7559
7560 unsafe impl<___E, T0>
7561 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
7562 for RealmGetResolvedInfoResponse<T0>
7563 where
7564 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7565 ___E: ::fidl_next::Encoder,
7566 ___E: ::fidl_next::fuchsia::HandleEncoder,
7567 T0: ::fidl_next::Encode<
7568 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
7569 ___E,
7570 >,
7571 {
7572 #[inline]
7573 fn encode(
7574 self,
7575 encoder_: &mut ___E,
7576 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
7577 _: (),
7578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7579 ::fidl_next::munge! {
7580 let crate::wire::RealmGetResolvedInfoResponse {
7581 resolved_info,
7582
7583 } = out_;
7584 }
7585
7586 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
7587
7588 Ok(())
7589 }
7590 }
7591
7592 pub struct StorageAdminListStorageInRealmRequest<T0, T1> {
7594 pub relative_moniker: T0,
7595
7596 pub iterator: T1,
7597 }
7598
7599 unsafe impl<___E, T0, T1>
7600 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
7601 for StorageAdminListStorageInRealmRequest<T0, T1>
7602 where
7603 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7604 ___E: ::fidl_next::Encoder,
7605 ___E: ::fidl_next::fuchsia::HandleEncoder,
7606 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7607 T1: ::fidl_next::Encode<
7608 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
7609 ___E,
7610 >,
7611 {
7612 #[inline]
7613 fn encode(
7614 self,
7615 encoder_: &mut ___E,
7616 out_: &mut ::core::mem::MaybeUninit<
7617 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
7618 >,
7619 _: (),
7620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7621 ::fidl_next::munge! {
7622 let crate::wire::StorageAdminListStorageInRealmRequest {
7623 relative_moniker,
7624 iterator,
7625
7626 } = out_;
7627 }
7628
7629 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7630
7631 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7632
7633 Ok(())
7634 }
7635 }
7636
7637 pub struct StorageAdminOpenStorageRequest<T0, T1> {
7639 pub relative_moniker: T0,
7640
7641 pub object: T1,
7642 }
7643
7644 unsafe impl<___E, T0, T1>
7645 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
7646 for StorageAdminOpenStorageRequest<T0, T1>
7647 where
7648 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7649 ___E: ::fidl_next::Encoder,
7650 ___E: ::fidl_next::fuchsia::HandleEncoder,
7651 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7652 T1: ::fidl_next::Encode<
7653 ::fidl_next::ServerEnd<
7654 ::fidl_next_fuchsia_io::Node,
7655 ::fidl_next::wire::fuchsia::Channel,
7656 >,
7657 ___E,
7658 >,
7659 {
7660 #[inline]
7661 fn encode(
7662 self,
7663 encoder_: &mut ___E,
7664 out_: &mut ::core::mem::MaybeUninit<
7665 crate::wire::StorageAdminOpenStorageRequest<'static>,
7666 >,
7667 _: (),
7668 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7669 ::fidl_next::munge! {
7670 let crate::wire::StorageAdminOpenStorageRequest {
7671 relative_moniker,
7672 object,
7673
7674 } = out_;
7675 }
7676
7677 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7678
7679 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7680
7681 Ok(())
7682 }
7683 }
7684
7685 pub struct StorageAdminOpenComponentStorageByIdRequest<T0, T1> {
7687 pub id: T0,
7688
7689 pub object: T1,
7690 }
7691
7692 unsafe impl<___E, T0, T1>
7693 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
7694 for StorageAdminOpenComponentStorageByIdRequest<T0, T1>
7695 where
7696 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7697 ___E: ::fidl_next::Encoder,
7698 ___E: ::fidl_next::fuchsia::HandleEncoder,
7699 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7700 T1: ::fidl_next::Encode<
7701 ::fidl_next::ServerEnd<
7702 ::fidl_next_fuchsia_io::Node,
7703 ::fidl_next::wire::fuchsia::Channel,
7704 >,
7705 ___E,
7706 >,
7707 {
7708 #[inline]
7709 fn encode(
7710 self,
7711 encoder_: &mut ___E,
7712 out_: &mut ::core::mem::MaybeUninit<
7713 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
7714 >,
7715 _: (),
7716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7717 ::fidl_next::munge! {
7718 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
7719 id,
7720 object,
7721
7722 } = out_;
7723 }
7724
7725 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
7726
7727 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7728
7729 Ok(())
7730 }
7731 }
7732}
7733
7734pub use self::natural::*;
7735
7736#[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"]
7738#[derive(PartialEq, Debug)]
7739pub struct Controller;
7740
7741#[cfg(target_os = "fuchsia")]
7742impl ::fidl_next::HasTransport for Controller {
7743 type Transport = ::fidl_next::fuchsia::zx::Channel;
7744}
7745
7746pub mod controller {
7747 pub mod prelude {
7748 pub use crate::{
7749 Controller, ControllerClientHandler, ControllerLocalClientHandler,
7750 ControllerLocalServerHandler, ControllerServerHandler, controller,
7751 };
7752
7753 pub use crate::natural::ControllerOpenExposedDirRequest;
7754
7755 pub use crate::natural::ControllerStartRequest;
7756
7757 pub use crate::natural::ControllerDestroyResponse;
7758
7759 pub use crate::natural::ControllerGetExposedDictionaryResponse;
7760
7761 pub use crate::natural::ControllerGetOutputDictionaryResponse;
7762
7763 pub use crate::natural::ControllerIsStartedResponse;
7764
7765 pub use crate::natural::ControllerOpenExposedDirResponse;
7766
7767 pub use crate::natural::ControllerStartResponse;
7768
7769 pub use crate::natural::Error;
7770 }
7771
7772 pub struct Start;
7773
7774 impl ::fidl_next::Method for Start {
7775 const ORDINAL: u64 = 7532130149195770565;
7776 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7777 ::fidl_next::protocol::Flexibility::Flexible;
7778
7779 type Protocol = crate::Controller;
7780
7781 type Request = crate::wire::ControllerStartRequest<'static>;
7782 }
7783
7784 impl ::fidl_next::TwoWayMethod for Start {
7785 type Response = ::fidl_next::wire::FlexibleResult<
7786 'static,
7787 crate::wire::ControllerStartResponse,
7788 crate::wire::Error,
7789 >;
7790 }
7791
7792 impl<___R> ::fidl_next::Respond<___R> for Start {
7793 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7794
7795 fn respond(response: ___R) -> Self::Output {
7796 ::fidl_next::FlexibleResult::Ok(response)
7797 }
7798 }
7799
7800 impl<___R> ::fidl_next::RespondErr<___R> for Start {
7801 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7802
7803 fn respond_err(response: ___R) -> Self::Output {
7804 ::fidl_next::FlexibleResult::Err(response)
7805 }
7806 }
7807
7808 pub struct IsStarted;
7809
7810 impl ::fidl_next::Method for IsStarted {
7811 const ORDINAL: u64 = 2402079833990398915;
7812 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7813 ::fidl_next::protocol::Flexibility::Flexible;
7814
7815 type Protocol = crate::Controller;
7816
7817 type Request = ::fidl_next::wire::EmptyMessageBody;
7818 }
7819
7820 impl ::fidl_next::TwoWayMethod for IsStarted {
7821 type Response = ::fidl_next::wire::FlexibleResult<
7822 'static,
7823 crate::wire::ControllerIsStartedResponse,
7824 crate::wire::Error,
7825 >;
7826 }
7827
7828 impl<___R> ::fidl_next::Respond<___R> for IsStarted {
7829 type Output = ::fidl_next::FlexibleResult<
7830 crate::generic::ControllerIsStartedResponse<___R>,
7831 ::fidl_next::util::Never,
7832 >;
7833
7834 fn respond(response: ___R) -> Self::Output {
7835 ::fidl_next::FlexibleResult::Ok(crate::generic::ControllerIsStartedResponse {
7836 is_started: response,
7837 })
7838 }
7839 }
7840
7841 impl<___R> ::fidl_next::RespondErr<___R> for IsStarted {
7842 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7843
7844 fn respond_err(response: ___R) -> Self::Output {
7845 ::fidl_next::FlexibleResult::Err(response)
7846 }
7847 }
7848
7849 pub struct OpenExposedDir;
7850
7851 impl ::fidl_next::Method for OpenExposedDir {
7852 const ORDINAL: u64 = 2683208291886099860;
7853 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7854 ::fidl_next::protocol::Flexibility::Strict;
7855
7856 type Protocol = crate::Controller;
7857
7858 type Request = crate::wire::ControllerOpenExposedDirRequest;
7859 }
7860
7861 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
7862 type Response = ::fidl_next::wire::Result<
7863 'static,
7864 crate::wire::ControllerOpenExposedDirResponse,
7865 crate::wire::Error,
7866 >;
7867 }
7868
7869 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
7870 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7871
7872 fn respond(response: ___R) -> Self::Output {
7873 ::core::result::Result::Ok(response)
7874 }
7875 }
7876
7877 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
7878 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7879
7880 fn respond_err(response: ___R) -> Self::Output {
7881 ::core::result::Result::Err(response)
7882 }
7883 }
7884
7885 pub struct GetExposedDictionary;
7886
7887 impl ::fidl_next::Method for GetExposedDictionary {
7888 const ORDINAL: u64 = 9099583788120940443;
7889 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7890 ::fidl_next::protocol::Flexibility::Flexible;
7891
7892 type Protocol = crate::Controller;
7893
7894 type Request = ::fidl_next::wire::EmptyMessageBody;
7895 }
7896
7897 impl ::fidl_next::TwoWayMethod for GetExposedDictionary {
7898 type Response = ::fidl_next::wire::FlexibleResult<
7899 'static,
7900 crate::wire::ControllerGetExposedDictionaryResponse,
7901 crate::wire::Error,
7902 >;
7903 }
7904
7905 impl<___R> ::fidl_next::Respond<___R> for GetExposedDictionary {
7906 type Output = ::fidl_next::FlexibleResult<
7907 crate::generic::ControllerGetExposedDictionaryResponse<___R>,
7908 ::fidl_next::util::Never,
7909 >;
7910
7911 fn respond(response: ___R) -> Self::Output {
7912 ::fidl_next::FlexibleResult::Ok(
7913 crate::generic::ControllerGetExposedDictionaryResponse { dictionary: response },
7914 )
7915 }
7916 }
7917
7918 impl<___R> ::fidl_next::RespondErr<___R> for GetExposedDictionary {
7919 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7920
7921 fn respond_err(response: ___R) -> Self::Output {
7922 ::fidl_next::FlexibleResult::Err(response)
7923 }
7924 }
7925
7926 pub struct GetOutputDictionary;
7927
7928 impl ::fidl_next::Method for GetOutputDictionary {
7929 const ORDINAL: u64 = 4182795765624263201;
7930 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7931 ::fidl_next::protocol::Flexibility::Flexible;
7932
7933 type Protocol = crate::Controller;
7934
7935 type Request = ::fidl_next::wire::EmptyMessageBody;
7936 }
7937
7938 impl ::fidl_next::TwoWayMethod for GetOutputDictionary {
7939 type Response = ::fidl_next::wire::FlexibleResult<
7940 'static,
7941 crate::wire::ControllerGetOutputDictionaryResponse,
7942 crate::wire::Error,
7943 >;
7944 }
7945
7946 impl<___R> ::fidl_next::Respond<___R> for GetOutputDictionary {
7947 type Output = ::fidl_next::FlexibleResult<
7948 crate::generic::ControllerGetOutputDictionaryResponse<___R>,
7949 ::fidl_next::util::Never,
7950 >;
7951
7952 fn respond(response: ___R) -> Self::Output {
7953 ::fidl_next::FlexibleResult::Ok(crate::generic::ControllerGetOutputDictionaryResponse {
7954 dictionary: response,
7955 })
7956 }
7957 }
7958
7959 impl<___R> ::fidl_next::RespondErr<___R> for GetOutputDictionary {
7960 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7961
7962 fn respond_err(response: ___R) -> Self::Output {
7963 ::fidl_next::FlexibleResult::Err(response)
7964 }
7965 }
7966
7967 pub struct Destroy;
7968
7969 impl ::fidl_next::Method for Destroy {
7970 const ORDINAL: u64 = 8381937394141370177;
7971 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7972 ::fidl_next::protocol::Flexibility::Flexible;
7973
7974 type Protocol = crate::Controller;
7975
7976 type Request = ::fidl_next::wire::EmptyMessageBody;
7977 }
7978
7979 impl ::fidl_next::TwoWayMethod for Destroy {
7980 type Response = ::fidl_next::wire::FlexibleResult<
7981 'static,
7982 crate::wire::ControllerDestroyResponse,
7983 crate::wire::Error,
7984 >;
7985 }
7986
7987 impl<___R> ::fidl_next::Respond<___R> for Destroy {
7988 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7989
7990 fn respond(response: ___R) -> Self::Output {
7991 ::fidl_next::FlexibleResult::Ok(response)
7992 }
7993 }
7994
7995 impl<___R> ::fidl_next::RespondErr<___R> for Destroy {
7996 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7997
7998 fn respond_err(response: ___R) -> Self::Output {
7999 ::fidl_next::FlexibleResult::Err(response)
8000 }
8001 }
8002
8003 mod ___detail {
8004 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Controller
8005 where
8006 ___T: ::fidl_next::Transport,
8007 {
8008 type Client = ControllerClient<___T>;
8009 type Server = ControllerServer<___T>;
8010 }
8011
8012 #[repr(transparent)]
8014 pub struct ControllerClient<___T: ::fidl_next::Transport> {
8015 #[allow(dead_code)]
8016 client: ::fidl_next::protocol::Client<___T>,
8017 }
8018
8019 impl<___T> ControllerClient<___T>
8020 where
8021 ___T: ::fidl_next::Transport,
8022 {
8023 #[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"]
8024 pub fn start(
8025 &self,
8026
8027 args: impl ::fidl_next::Encode<
8028 crate::wire::StartChildArgs<'static>,
8029 <___T as ::fidl_next::Transport>::SendBuffer,
8030 >,
8031
8032 execution_controller: impl ::fidl_next::Encode<
8033 ::fidl_next::ServerEnd<
8034 crate::ExecutionController,
8035 ::fidl_next::wire::fuchsia::Channel,
8036 >,
8037 <___T as ::fidl_next::Transport>::SendBuffer,
8038 >,
8039 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8040 where
8041 <___T as ::fidl_next::Transport>::SendBuffer:
8042 ::fidl_next::encoder::InternalHandleEncoder,
8043 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8044 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8045 {
8046 self.start_with(crate::generic::ControllerStartRequest {
8047 args,
8048
8049 execution_controller,
8050 })
8051 }
8052
8053 #[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"]
8054 pub fn start_with<___R>(
8055 &self,
8056 request: ___R,
8057 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8058 where
8059 ___R: ::fidl_next::Encode<
8060 crate::wire::ControllerStartRequest<'static>,
8061 <___T as ::fidl_next::Transport>::SendBuffer,
8062 >,
8063 {
8064 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8065 7532130149195770565,
8066 <super::Start as ::fidl_next::Method>::FLEXIBILITY,
8067 request,
8068 ))
8069 }
8070
8071 #[doc = " Returns true if this instance is currently running.\n"]
8072 pub fn is_started(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsStarted, ___T> {
8073 ::fidl_next::TwoWayFuture::from_untyped(
8074 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8075 2402079833990398915,
8076 <super::IsStarted as ::fidl_next::Method>::FLEXIBILITY,
8077 (),
8078 ),
8079 )
8080 }
8081
8082 #[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"]
8083 pub fn open_exposed_dir(
8084 &self,
8085
8086 exposed_dir: impl ::fidl_next::Encode<
8087 ::fidl_next::ServerEnd<
8088 ::fidl_next_fuchsia_io::Directory,
8089 ::fidl_next::wire::fuchsia::Channel,
8090 >,
8091 <___T as ::fidl_next::Transport>::SendBuffer,
8092 >,
8093 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8094 where
8095 <___T as ::fidl_next::Transport>::SendBuffer:
8096 ::fidl_next::encoder::InternalHandleEncoder,
8097 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8098 {
8099 self.open_exposed_dir_with(crate::generic::ControllerOpenExposedDirRequest {
8100 exposed_dir,
8101 })
8102 }
8103
8104 #[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"]
8105 pub fn open_exposed_dir_with<___R>(
8106 &self,
8107 request: ___R,
8108 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8109 where
8110 ___R: ::fidl_next::Encode<
8111 crate::wire::ControllerOpenExposedDirRequest,
8112 <___T as ::fidl_next::Transport>::SendBuffer,
8113 >,
8114 {
8115 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8116 2683208291886099860,
8117 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
8118 request,
8119 ))
8120 }
8121
8122 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8123 pub fn get_exposed_dictionary(
8124 &self,
8125 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExposedDictionary, ___T> {
8126 ::fidl_next::TwoWayFuture::from_untyped(
8127 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8128 9099583788120940443,
8129 <super::GetExposedDictionary as ::fidl_next::Method>::FLEXIBILITY,
8130 (),
8131 ),
8132 )
8133 }
8134
8135 #[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"]
8136 pub fn get_output_dictionary(
8137 &self,
8138 ) -> ::fidl_next::TwoWayFuture<'_, super::GetOutputDictionary, ___T> {
8139 ::fidl_next::TwoWayFuture::from_untyped(
8140 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8141 4182795765624263201,
8142 <super::GetOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
8143 (),
8144 ),
8145 )
8146 }
8147
8148 #[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"]
8149 pub fn destroy(&self) -> ::fidl_next::TwoWayFuture<'_, super::Destroy, ___T> {
8150 ::fidl_next::TwoWayFuture::from_untyped(
8151 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8152 8381937394141370177,
8153 <super::Destroy as ::fidl_next::Method>::FLEXIBILITY,
8154 (),
8155 ),
8156 )
8157 }
8158 }
8159
8160 #[repr(transparent)]
8162 pub struct ControllerServer<___T: ::fidl_next::Transport> {
8163 server: ::fidl_next::protocol::Server<___T>,
8164 }
8165
8166 impl<___T> ControllerServer<___T> where ___T: ::fidl_next::Transport {}
8167 }
8168}
8169
8170#[diagnostic::on_unimplemented(
8171 note = "If {Self} implements the non-local ControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
8172)]
8173
8174pub trait ControllerLocalClientHandler<
8178 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8179 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8180>
8181{
8182 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8183 ::core::future::ready(())
8184 }
8185}
8186
8187impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Controller
8188where
8189 ___H: ControllerLocalClientHandler<___T>,
8190 ___T: ::fidl_next::Transport,
8191{
8192 async fn on_event(
8193 handler: &mut ___H,
8194 ordinal: u64,
8195 flexibility: ::fidl_next::protocol::Flexibility,
8196 body: ::fidl_next::Body<___T>,
8197 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8198 match ordinal {
8199 ordinal => {
8200 handler.on_unknown_interaction(ordinal).await;
8201 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8202 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8203 } else {
8204 Ok(())
8205 }
8206 }
8207 }
8208 }
8209}
8210
8211#[diagnostic::on_unimplemented(
8212 note = "If {Self} implements the non-local ControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
8213)]
8214
8215pub trait ControllerLocalServerHandler<
8219 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8220 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8221>
8222{
8223 #[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"]
8224 fn start(
8225 &mut self,
8226
8227 request: ::fidl_next::Request<controller::Start, ___T>,
8228
8229 responder: ::fidl_next::Responder<controller::Start, ___T>,
8230 ) -> impl ::core::future::Future<Output = ()>;
8231
8232 #[doc = " Returns true if this instance is currently running.\n"]
8233 fn is_started(
8234 &mut self,
8235
8236 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8237 ) -> impl ::core::future::Future<Output = ()>;
8238
8239 #[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"]
8240 fn open_exposed_dir(
8241 &mut self,
8242
8243 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8244
8245 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8246 ) -> impl ::core::future::Future<Output = ()>;
8247
8248 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8249 fn get_exposed_dictionary(
8250 &mut self,
8251
8252 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8253 ) -> impl ::core::future::Future<Output = ()>;
8254
8255 #[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"]
8256 fn get_output_dictionary(
8257 &mut self,
8258
8259 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8260 ) -> impl ::core::future::Future<Output = ()>;
8261
8262 #[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"]
8263 fn destroy(
8264 &mut self,
8265
8266 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8267 ) -> impl ::core::future::Future<Output = ()>;
8268
8269 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8270 ::core::future::ready(())
8271 }
8272}
8273
8274impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Controller
8275where
8276 ___H: ControllerLocalServerHandler<___T>,
8277 ___T: ::fidl_next::Transport,
8278 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8279 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8280 Constraint = (),
8281 >,
8282 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8283 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8284 Constraint = (),
8285 >,
8286{
8287 async fn on_one_way(
8288 handler: &mut ___H,
8289 ordinal: u64,
8290 flexibility: ::fidl_next::protocol::Flexibility,
8291 body: ::fidl_next::Body<___T>,
8292 ) -> ::core::result::Result<
8293 (),
8294 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8295 > {
8296 match ordinal {
8297 ordinal => {
8298 handler.on_unknown_interaction(ordinal).await;
8299 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8300 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8301 } else {
8302 Ok(())
8303 }
8304 }
8305 }
8306 }
8307
8308 async fn on_two_way(
8309 handler: &mut ___H,
8310 ordinal: u64,
8311 flexibility: ::fidl_next::protocol::Flexibility,
8312 body: ::fidl_next::Body<___T>,
8313 responder: ::fidl_next::protocol::Responder<___T>,
8314 ) -> ::core::result::Result<
8315 (),
8316 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8317 > {
8318 match ordinal {
8319 7532130149195770565 => {
8320 let responder = ::fidl_next::Responder::from_untyped(responder);
8321
8322 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8323 Ok(decoded) => {
8324 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8325 Ok(())
8326 }
8327 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8328 ordinal: 7532130149195770565,
8329 error,
8330 }),
8331 }
8332 }
8333
8334 2402079833990398915 => {
8335 let responder = ::fidl_next::Responder::from_untyped(responder);
8336
8337 handler.is_started(responder).await;
8338 Ok(())
8339 }
8340
8341 2683208291886099860 => {
8342 let responder = ::fidl_next::Responder::from_untyped(responder);
8343
8344 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8345 Ok(decoded) => {
8346 handler
8347 .open_exposed_dir(
8348 ::fidl_next::Request::from_decoded(decoded),
8349 responder,
8350 )
8351 .await;
8352 Ok(())
8353 }
8354 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8355 ordinal: 2683208291886099860,
8356 error,
8357 }),
8358 }
8359 }
8360
8361 9099583788120940443 => {
8362 let responder = ::fidl_next::Responder::from_untyped(responder);
8363
8364 handler.get_exposed_dictionary(responder).await;
8365 Ok(())
8366 }
8367
8368 4182795765624263201 => {
8369 let responder = ::fidl_next::Responder::from_untyped(responder);
8370
8371 handler.get_output_dictionary(responder).await;
8372 Ok(())
8373 }
8374
8375 8381937394141370177 => {
8376 let responder = ::fidl_next::Responder::from_untyped(responder);
8377
8378 handler.destroy(responder).await;
8379 Ok(())
8380 }
8381
8382 ordinal => {
8383 handler.on_unknown_interaction(ordinal).await;
8384 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8385 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8386 } else {
8387 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
8388 ordinal,
8389 flexibility,
8390 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
8391 )
8392 .expect("encoding a framework error should never fail")
8393 .await?;
8394 Ok(())
8395 }
8396 }
8397 }
8398 }
8399}
8400
8401pub trait ControllerClientHandler<
8405 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8406 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8407>
8408{
8409 fn on_unknown_interaction(
8410 &mut self,
8411 ordinal: u64,
8412 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8413 ::core::future::ready(())
8414 }
8415}
8416
8417impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Controller
8418where
8419 ___H: ControllerClientHandler<___T> + ::core::marker::Send,
8420 ___T: ::fidl_next::Transport,
8421{
8422 async fn on_event(
8423 handler: &mut ___H,
8424 ordinal: u64,
8425 flexibility: ::fidl_next::protocol::Flexibility,
8426 body: ::fidl_next::Body<___T>,
8427 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8428 match ordinal {
8429 ordinal => {
8430 handler.on_unknown_interaction(ordinal).await;
8431 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8432 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8433 } else {
8434 Ok(())
8435 }
8436 }
8437 }
8438 }
8439}
8440
8441pub trait ControllerServerHandler<
8445 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8446 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8447>
8448{
8449 #[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"]
8450 fn start(
8451 &mut self,
8452
8453 request: ::fidl_next::Request<controller::Start, ___T>,
8454
8455 responder: ::fidl_next::Responder<controller::Start, ___T>,
8456 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8457
8458 #[doc = " Returns true if this instance is currently running.\n"]
8459 fn is_started(
8460 &mut self,
8461
8462 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8463 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8464
8465 #[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"]
8466 fn open_exposed_dir(
8467 &mut self,
8468
8469 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8470
8471 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8472 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8473
8474 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8475 fn get_exposed_dictionary(
8476 &mut self,
8477
8478 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8479 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8480
8481 #[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"]
8482 fn get_output_dictionary(
8483 &mut self,
8484
8485 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8486 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8487
8488 #[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"]
8489 fn destroy(
8490 &mut self,
8491
8492 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8493 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8494
8495 fn on_unknown_interaction(
8496 &mut self,
8497 ordinal: u64,
8498 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8499 ::core::future::ready(())
8500 }
8501}
8502
8503impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Controller
8504where
8505 ___H: ControllerServerHandler<___T> + ::core::marker::Send,
8506 ___T: ::fidl_next::Transport,
8507 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8508 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8509 Constraint = (),
8510 >,
8511 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8512 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8513 Constraint = (),
8514 >,
8515{
8516 async fn on_one_way(
8517 handler: &mut ___H,
8518 ordinal: u64,
8519 flexibility: ::fidl_next::protocol::Flexibility,
8520 body: ::fidl_next::Body<___T>,
8521 ) -> ::core::result::Result<
8522 (),
8523 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8524 > {
8525 match ordinal {
8526 ordinal => {
8527 handler.on_unknown_interaction(ordinal).await;
8528 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8529 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8530 } else {
8531 Ok(())
8532 }
8533 }
8534 }
8535 }
8536
8537 async fn on_two_way(
8538 handler: &mut ___H,
8539 ordinal: u64,
8540 flexibility: ::fidl_next::protocol::Flexibility,
8541 body: ::fidl_next::Body<___T>,
8542 responder: ::fidl_next::protocol::Responder<___T>,
8543 ) -> ::core::result::Result<
8544 (),
8545 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8546 > {
8547 match ordinal {
8548 7532130149195770565 => {
8549 let responder = ::fidl_next::Responder::from_untyped(responder);
8550
8551 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8552 Ok(decoded) => {
8553 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8554 Ok(())
8555 }
8556 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8557 ordinal: 7532130149195770565,
8558 error,
8559 }),
8560 }
8561 }
8562
8563 2402079833990398915 => {
8564 let responder = ::fidl_next::Responder::from_untyped(responder);
8565
8566 handler.is_started(responder).await;
8567 Ok(())
8568 }
8569
8570 2683208291886099860 => {
8571 let responder = ::fidl_next::Responder::from_untyped(responder);
8572
8573 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8574 Ok(decoded) => {
8575 handler
8576 .open_exposed_dir(
8577 ::fidl_next::Request::from_decoded(decoded),
8578 responder,
8579 )
8580 .await;
8581 Ok(())
8582 }
8583 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8584 ordinal: 2683208291886099860,
8585 error,
8586 }),
8587 }
8588 }
8589
8590 9099583788120940443 => {
8591 let responder = ::fidl_next::Responder::from_untyped(responder);
8592
8593 handler.get_exposed_dictionary(responder).await;
8594 Ok(())
8595 }
8596
8597 4182795765624263201 => {
8598 let responder = ::fidl_next::Responder::from_untyped(responder);
8599
8600 handler.get_output_dictionary(responder).await;
8601 Ok(())
8602 }
8603
8604 8381937394141370177 => {
8605 let responder = ::fidl_next::Responder::from_untyped(responder);
8606
8607 handler.destroy(responder).await;
8608 Ok(())
8609 }
8610
8611 ordinal => {
8612 handler.on_unknown_interaction(ordinal).await;
8613 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8614 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8615 } else {
8616 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
8617 ordinal,
8618 flexibility,
8619 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
8620 )
8621 .expect("encoding a framework error should never fail")
8622 .await?;
8623 Ok(())
8624 }
8625 }
8626 }
8627 }
8628}
8629
8630impl<___T> ControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
8631where
8632 ___T: ::fidl_next::Transport,
8633{
8634 async fn on_unknown_interaction(&mut self, _: u64) {}
8635}
8636
8637impl<___H, ___T> ControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
8638where
8639 ___H: ControllerClientHandler<___T>,
8640 ___T: ::fidl_next::Transport,
8641{
8642 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8643 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8644 }
8645}
8646
8647impl<___H, ___T> ControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
8648where
8649 ___H: ControllerServerHandler<___T>,
8650 ___T: ::fidl_next::Transport,
8651{
8652 async fn start(
8653 &mut self,
8654
8655 request: ::fidl_next::Request<controller::Start, ___T>,
8656
8657 responder: ::fidl_next::Responder<controller::Start, ___T>,
8658 ) {
8659 ___H::start(&mut self.0, request, responder).await
8660 }
8661
8662 async fn is_started(&mut self, responder: ::fidl_next::Responder<controller::IsStarted, ___T>) {
8663 ___H::is_started(&mut self.0, responder).await
8664 }
8665
8666 async fn open_exposed_dir(
8667 &mut self,
8668
8669 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8670
8671 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8672 ) {
8673 ___H::open_exposed_dir(&mut self.0, request, responder).await
8674 }
8675
8676 async fn get_exposed_dictionary(
8677 &mut self,
8678
8679 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8680 ) {
8681 ___H::get_exposed_dictionary(&mut self.0, responder).await
8682 }
8683
8684 async fn get_output_dictionary(
8685 &mut self,
8686
8687 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8688 ) {
8689 ___H::get_output_dictionary(&mut self.0, responder).await
8690 }
8691
8692 async fn destroy(&mut self, responder: ::fidl_next::Responder<controller::Destroy, ___T>) {
8693 ___H::destroy(&mut self.0, responder).await
8694 }
8695
8696 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8697 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8698 }
8699}
8700
8701#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
8703#[derive(PartialEq, Debug)]
8704pub struct EventStream;
8705
8706impl ::fidl_next::Discoverable for EventStream {
8707 const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
8708}
8709
8710#[cfg(target_os = "fuchsia")]
8711impl ::fidl_next::HasTransport for EventStream {
8712 type Transport = ::fidl_next::fuchsia::zx::Channel;
8713}
8714
8715pub mod event_stream {
8716 pub mod prelude {
8717 pub use crate::{
8718 EventStream, EventStreamClientHandler, EventStreamLocalClientHandler,
8719 EventStreamLocalServerHandler, EventStreamServerHandler, event_stream,
8720 };
8721
8722 pub use crate::natural::EventStreamGetNextResponse;
8723 }
8724
8725 pub struct GetNext;
8726
8727 impl ::fidl_next::Method for GetNext {
8728 const ORDINAL: u64 = 4549982840421936006;
8729 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8730 ::fidl_next::protocol::Flexibility::Strict;
8731
8732 type Protocol = crate::EventStream;
8733
8734 type Request = ::fidl_next::wire::EmptyMessageBody;
8735 }
8736
8737 impl ::fidl_next::TwoWayMethod for GetNext {
8738 type Response = crate::wire::EventStreamGetNextResponse<'static>;
8739 }
8740
8741 impl<___R> ::fidl_next::Respond<___R> for GetNext {
8742 type Output = crate::generic::EventStreamGetNextResponse<___R>;
8743
8744 fn respond(response: ___R) -> Self::Output {
8745 crate::generic::EventStreamGetNextResponse { events: response }
8746 }
8747 }
8748
8749 pub struct WaitForReady;
8750
8751 impl ::fidl_next::Method for WaitForReady {
8752 const ORDINAL: u64 = 3545212058508387970;
8753 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8754 ::fidl_next::protocol::Flexibility::Strict;
8755
8756 type Protocol = crate::EventStream;
8757
8758 type Request = ::fidl_next::wire::EmptyMessageBody;
8759 }
8760
8761 impl ::fidl_next::TwoWayMethod for WaitForReady {
8762 type Response = ::fidl_next::wire::EmptyMessageBody;
8763 }
8764
8765 impl<___R> ::fidl_next::Respond<___R> for WaitForReady {
8766 type Output = ___R;
8767
8768 fn respond(response: ___R) -> Self::Output {
8769 response
8770 }
8771 }
8772
8773 mod ___detail {
8774 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::EventStream
8775 where
8776 ___T: ::fidl_next::Transport,
8777 {
8778 type Client = EventStreamClient<___T>;
8779 type Server = EventStreamServer<___T>;
8780 }
8781
8782 #[repr(transparent)]
8784 pub struct EventStreamClient<___T: ::fidl_next::Transport> {
8785 #[allow(dead_code)]
8786 client: ::fidl_next::protocol::Client<___T>,
8787 }
8788
8789 impl<___T> EventStreamClient<___T>
8790 where
8791 ___T: ::fidl_next::Transport,
8792 {
8793 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
8794 ::fidl_next::TwoWayFuture::from_untyped(
8795 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8796 4549982840421936006,
8797 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
8798 (),
8799 ),
8800 )
8801 }
8802
8803 #[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"]
8804 pub fn wait_for_ready(
8805 &self,
8806 ) -> ::fidl_next::TwoWayFuture<'_, super::WaitForReady, ___T> {
8807 ::fidl_next::TwoWayFuture::from_untyped(
8808 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8809 3545212058508387970,
8810 <super::WaitForReady as ::fidl_next::Method>::FLEXIBILITY,
8811 (),
8812 ),
8813 )
8814 }
8815 }
8816
8817 #[repr(transparent)]
8819 pub struct EventStreamServer<___T: ::fidl_next::Transport> {
8820 server: ::fidl_next::protocol::Server<___T>,
8821 }
8822
8823 impl<___T> EventStreamServer<___T> where ___T: ::fidl_next::Transport {}
8824 }
8825}
8826
8827#[diagnostic::on_unimplemented(
8828 note = "If {Self} implements the non-local EventStreamClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
8829)]
8830
8831pub trait EventStreamLocalClientHandler<
8835 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8836 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8837>
8838{
8839}
8840
8841impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for EventStream
8842where
8843 ___H: EventStreamLocalClientHandler<___T>,
8844 ___T: ::fidl_next::Transport,
8845{
8846 async fn on_event(
8847 handler: &mut ___H,
8848 ordinal: u64,
8849 flexibility: ::fidl_next::protocol::Flexibility,
8850 body: ::fidl_next::Body<___T>,
8851 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8852 match ordinal {
8853 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8854 }
8855 }
8856}
8857
8858#[diagnostic::on_unimplemented(
8859 note = "If {Self} implements the non-local EventStreamServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
8860)]
8861
8862pub trait EventStreamLocalServerHandler<
8866 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8867 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8868>
8869{
8870 fn get_next(
8871 &mut self,
8872
8873 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
8874 ) -> impl ::core::future::Future<Output = ()>;
8875
8876 #[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"]
8877 fn wait_for_ready(
8878 &mut self,
8879
8880 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
8881 ) -> impl ::core::future::Future<Output = ()>;
8882}
8883
8884impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for EventStream
8885where
8886 ___H: EventStreamLocalServerHandler<___T>,
8887 ___T: ::fidl_next::Transport,
8888{
8889 async fn on_one_way(
8890 handler: &mut ___H,
8891 ordinal: u64,
8892 flexibility: ::fidl_next::protocol::Flexibility,
8893 body: ::fidl_next::Body<___T>,
8894 ) -> ::core::result::Result<
8895 (),
8896 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8897 > {
8898 match ordinal {
8899 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8900 }
8901 }
8902
8903 async fn on_two_way(
8904 handler: &mut ___H,
8905 ordinal: u64,
8906 flexibility: ::fidl_next::protocol::Flexibility,
8907 body: ::fidl_next::Body<___T>,
8908 responder: ::fidl_next::protocol::Responder<___T>,
8909 ) -> ::core::result::Result<
8910 (),
8911 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8912 > {
8913 match ordinal {
8914 4549982840421936006 => {
8915 let responder = ::fidl_next::Responder::from_untyped(responder);
8916
8917 handler.get_next(responder).await;
8918 Ok(())
8919 }
8920
8921 3545212058508387970 => {
8922 let responder = ::fidl_next::Responder::from_untyped(responder);
8923
8924 handler.wait_for_ready(responder).await;
8925 Ok(())
8926 }
8927
8928 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8929 }
8930 }
8931}
8932
8933pub trait EventStreamClientHandler<
8937 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8938 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8939>
8940{
8941}
8942
8943impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for EventStream
8944where
8945 ___H: EventStreamClientHandler<___T> + ::core::marker::Send,
8946 ___T: ::fidl_next::Transport,
8947{
8948 async fn on_event(
8949 handler: &mut ___H,
8950 ordinal: u64,
8951 flexibility: ::fidl_next::protocol::Flexibility,
8952 body: ::fidl_next::Body<___T>,
8953 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8954 match ordinal {
8955 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8956 }
8957 }
8958}
8959
8960pub trait EventStreamServerHandler<
8964 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8965 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8966>
8967{
8968 fn get_next(
8969 &mut self,
8970
8971 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
8972 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8973
8974 #[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"]
8975 fn wait_for_ready(
8976 &mut self,
8977
8978 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
8979 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8980}
8981
8982impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for EventStream
8983where
8984 ___H: EventStreamServerHandler<___T> + ::core::marker::Send,
8985 ___T: ::fidl_next::Transport,
8986{
8987 async fn on_one_way(
8988 handler: &mut ___H,
8989 ordinal: u64,
8990 flexibility: ::fidl_next::protocol::Flexibility,
8991 body: ::fidl_next::Body<___T>,
8992 ) -> ::core::result::Result<
8993 (),
8994 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8995 > {
8996 match ordinal {
8997 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8998 }
8999 }
9000
9001 async fn on_two_way(
9002 handler: &mut ___H,
9003 ordinal: u64,
9004 flexibility: ::fidl_next::protocol::Flexibility,
9005 body: ::fidl_next::Body<___T>,
9006 responder: ::fidl_next::protocol::Responder<___T>,
9007 ) -> ::core::result::Result<
9008 (),
9009 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9010 > {
9011 match ordinal {
9012 4549982840421936006 => {
9013 let responder = ::fidl_next::Responder::from_untyped(responder);
9014
9015 handler.get_next(responder).await;
9016 Ok(())
9017 }
9018
9019 3545212058508387970 => {
9020 let responder = ::fidl_next::Responder::from_untyped(responder);
9021
9022 handler.wait_for_ready(responder).await;
9023 Ok(())
9024 }
9025
9026 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9027 }
9028 }
9029}
9030
9031impl<___T> EventStreamClientHandler<___T> for ::fidl_next::IgnoreEvents where
9032 ___T: ::fidl_next::Transport
9033{
9034}
9035
9036impl<___H, ___T> EventStreamLocalClientHandler<___T> for ::fidl_next::Local<___H>
9037where
9038 ___H: EventStreamClientHandler<___T>,
9039 ___T: ::fidl_next::Transport,
9040{
9041}
9042
9043impl<___H, ___T> EventStreamLocalServerHandler<___T> for ::fidl_next::Local<___H>
9044where
9045 ___H: EventStreamServerHandler<___T>,
9046 ___T: ::fidl_next::Transport,
9047{
9048 async fn get_next(&mut self, responder: ::fidl_next::Responder<event_stream::GetNext, ___T>) {
9049 ___H::get_next(&mut self.0, responder).await
9050 }
9051
9052 async fn wait_for_ready(
9053 &mut self,
9054
9055 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9056 ) {
9057 ___H::wait_for_ready(&mut self.0, responder).await
9058 }
9059}
9060
9061#[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"]
9063#[derive(PartialEq, Debug)]
9064pub struct Introspector;
9065
9066impl ::fidl_next::Discoverable for Introspector {
9067 const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
9068}
9069
9070#[cfg(target_os = "fuchsia")]
9071impl ::fidl_next::HasTransport for Introspector {
9072 type Transport = ::fidl_next::fuchsia::zx::Channel;
9073}
9074
9075pub mod introspector {
9076 pub mod prelude {
9077 pub use crate::{
9078 Introspector, IntrospectorClientHandler, IntrospectorLocalClientHandler,
9079 IntrospectorLocalServerHandler, IntrospectorServerHandler, introspector,
9080 };
9081
9082 pub use crate::natural::Error;
9083
9084 pub use crate::natural::IntrospectorGetMonikerRequest;
9085
9086 pub use crate::natural::IntrospectorGetMonikerResponse;
9087 }
9088
9089 pub struct GetMoniker;
9090
9091 impl ::fidl_next::Method for GetMoniker {
9092 const ORDINAL: u64 = 214344082539672664;
9093 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9094 ::fidl_next::protocol::Flexibility::Flexible;
9095
9096 type Protocol = crate::Introspector;
9097
9098 type Request = crate::wire::IntrospectorGetMonikerRequest;
9099 }
9100
9101 impl ::fidl_next::TwoWayMethod for GetMoniker {
9102 type Response = ::fidl_next::wire::FlexibleResult<
9103 'static,
9104 crate::wire::IntrospectorGetMonikerResponse<'static>,
9105 crate::wire::Error,
9106 >;
9107 }
9108
9109 impl<___R> ::fidl_next::Respond<___R> for GetMoniker {
9110 type Output = ::fidl_next::FlexibleResult<
9111 crate::generic::IntrospectorGetMonikerResponse<___R>,
9112 ::fidl_next::util::Never,
9113 >;
9114
9115 fn respond(response: ___R) -> Self::Output {
9116 ::fidl_next::FlexibleResult::Ok(crate::generic::IntrospectorGetMonikerResponse {
9117 moniker: response,
9118 })
9119 }
9120 }
9121
9122 impl<___R> ::fidl_next::RespondErr<___R> for GetMoniker {
9123 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9124
9125 fn respond_err(response: ___R) -> Self::Output {
9126 ::fidl_next::FlexibleResult::Err(response)
9127 }
9128 }
9129
9130 mod ___detail {
9131 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Introspector
9132 where
9133 ___T: ::fidl_next::Transport,
9134 {
9135 type Client = IntrospectorClient<___T>;
9136 type Server = IntrospectorServer<___T>;
9137 }
9138
9139 #[repr(transparent)]
9141 pub struct IntrospectorClient<___T: ::fidl_next::Transport> {
9142 #[allow(dead_code)]
9143 client: ::fidl_next::protocol::Client<___T>,
9144 }
9145
9146 impl<___T> IntrospectorClient<___T>
9147 where
9148 ___T: ::fidl_next::Transport,
9149 {
9150 #[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"]
9151 pub fn get_moniker(
9152 &self,
9153
9154 component_instance: impl ::fidl_next::Encode<
9155 ::fidl_next::wire::fuchsia::Event,
9156 <___T as ::fidl_next::Transport>::SendBuffer,
9157 >,
9158 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9159 where
9160 <___T as ::fidl_next::Transport>::SendBuffer:
9161 ::fidl_next::encoder::InternalHandleEncoder,
9162 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9163 {
9164 self.get_moniker_with(crate::generic::IntrospectorGetMonikerRequest {
9165 component_instance,
9166 })
9167 }
9168
9169 #[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"]
9170 pub fn get_moniker_with<___R>(
9171 &self,
9172 request: ___R,
9173 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9174 where
9175 ___R: ::fidl_next::Encode<
9176 crate::wire::IntrospectorGetMonikerRequest,
9177 <___T as ::fidl_next::Transport>::SendBuffer,
9178 >,
9179 {
9180 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9181 214344082539672664,
9182 <super::GetMoniker as ::fidl_next::Method>::FLEXIBILITY,
9183 request,
9184 ))
9185 }
9186 }
9187
9188 #[repr(transparent)]
9190 pub struct IntrospectorServer<___T: ::fidl_next::Transport> {
9191 server: ::fidl_next::protocol::Server<___T>,
9192 }
9193
9194 impl<___T> IntrospectorServer<___T> where ___T: ::fidl_next::Transport {}
9195 }
9196}
9197
9198#[diagnostic::on_unimplemented(
9199 note = "If {Self} implements the non-local IntrospectorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9200)]
9201
9202pub trait IntrospectorLocalClientHandler<
9206 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9207 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9208>
9209{
9210 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9211 ::core::future::ready(())
9212 }
9213}
9214
9215impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Introspector
9216where
9217 ___H: IntrospectorLocalClientHandler<___T>,
9218 ___T: ::fidl_next::Transport,
9219{
9220 async fn on_event(
9221 handler: &mut ___H,
9222 ordinal: u64,
9223 flexibility: ::fidl_next::protocol::Flexibility,
9224 body: ::fidl_next::Body<___T>,
9225 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9226 match ordinal {
9227 ordinal => {
9228 handler.on_unknown_interaction(ordinal).await;
9229 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9230 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9231 } else {
9232 Ok(())
9233 }
9234 }
9235 }
9236 }
9237}
9238
9239#[diagnostic::on_unimplemented(
9240 note = "If {Self} implements the non-local IntrospectorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9241)]
9242
9243pub trait IntrospectorLocalServerHandler<
9247 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9248 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9249>
9250{
9251 #[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"]
9252 fn get_moniker(
9253 &mut self,
9254
9255 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9256
9257 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9258 ) -> impl ::core::future::Future<Output = ()>;
9259
9260 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9261 ::core::future::ready(())
9262 }
9263}
9264
9265impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Introspector
9266where
9267 ___H: IntrospectorLocalServerHandler<___T>,
9268 ___T: ::fidl_next::Transport,
9269 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9270 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9271 Constraint = (),
9272 >,
9273{
9274 async fn on_one_way(
9275 handler: &mut ___H,
9276 ordinal: u64,
9277 flexibility: ::fidl_next::protocol::Flexibility,
9278 body: ::fidl_next::Body<___T>,
9279 ) -> ::core::result::Result<
9280 (),
9281 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9282 > {
9283 match ordinal {
9284 ordinal => {
9285 handler.on_unknown_interaction(ordinal).await;
9286 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9287 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9288 } else {
9289 Ok(())
9290 }
9291 }
9292 }
9293 }
9294
9295 async fn on_two_way(
9296 handler: &mut ___H,
9297 ordinal: u64,
9298 flexibility: ::fidl_next::protocol::Flexibility,
9299 body: ::fidl_next::Body<___T>,
9300 responder: ::fidl_next::protocol::Responder<___T>,
9301 ) -> ::core::result::Result<
9302 (),
9303 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9304 > {
9305 match ordinal {
9306 214344082539672664 => {
9307 let responder = ::fidl_next::Responder::from_untyped(responder);
9308
9309 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9310 Ok(decoded) => {
9311 handler
9312 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9313 .await;
9314 Ok(())
9315 }
9316 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9317 ordinal: 214344082539672664,
9318 error,
9319 }),
9320 }
9321 }
9322
9323 ordinal => {
9324 handler.on_unknown_interaction(ordinal).await;
9325 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9326 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9327 } else {
9328 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
9329 ordinal,
9330 flexibility,
9331 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
9332 )
9333 .expect("encoding a framework error should never fail")
9334 .await?;
9335 Ok(())
9336 }
9337 }
9338 }
9339 }
9340}
9341
9342pub trait IntrospectorClientHandler<
9346 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9347 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9348>
9349{
9350 fn on_unknown_interaction(
9351 &mut self,
9352 ordinal: u64,
9353 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9354 ::core::future::ready(())
9355 }
9356}
9357
9358impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Introspector
9359where
9360 ___H: IntrospectorClientHandler<___T> + ::core::marker::Send,
9361 ___T: ::fidl_next::Transport,
9362{
9363 async fn on_event(
9364 handler: &mut ___H,
9365 ordinal: u64,
9366 flexibility: ::fidl_next::protocol::Flexibility,
9367 body: ::fidl_next::Body<___T>,
9368 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9369 match ordinal {
9370 ordinal => {
9371 handler.on_unknown_interaction(ordinal).await;
9372 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9373 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9374 } else {
9375 Ok(())
9376 }
9377 }
9378 }
9379 }
9380}
9381
9382pub trait IntrospectorServerHandler<
9386 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9387 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9388>
9389{
9390 #[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"]
9391 fn get_moniker(
9392 &mut self,
9393
9394 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9395
9396 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9397 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9398
9399 fn on_unknown_interaction(
9400 &mut self,
9401 ordinal: u64,
9402 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9403 ::core::future::ready(())
9404 }
9405}
9406
9407impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Introspector
9408where
9409 ___H: IntrospectorServerHandler<___T> + ::core::marker::Send,
9410 ___T: ::fidl_next::Transport,
9411 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9412 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9413 Constraint = (),
9414 >,
9415{
9416 async fn on_one_way(
9417 handler: &mut ___H,
9418 ordinal: u64,
9419 flexibility: ::fidl_next::protocol::Flexibility,
9420 body: ::fidl_next::Body<___T>,
9421 ) -> ::core::result::Result<
9422 (),
9423 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9424 > {
9425 match ordinal {
9426 ordinal => {
9427 handler.on_unknown_interaction(ordinal).await;
9428 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9429 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9430 } else {
9431 Ok(())
9432 }
9433 }
9434 }
9435 }
9436
9437 async fn on_two_way(
9438 handler: &mut ___H,
9439 ordinal: u64,
9440 flexibility: ::fidl_next::protocol::Flexibility,
9441 body: ::fidl_next::Body<___T>,
9442 responder: ::fidl_next::protocol::Responder<___T>,
9443 ) -> ::core::result::Result<
9444 (),
9445 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9446 > {
9447 match ordinal {
9448 214344082539672664 => {
9449 let responder = ::fidl_next::Responder::from_untyped(responder);
9450
9451 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9452 Ok(decoded) => {
9453 handler
9454 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9455 .await;
9456 Ok(())
9457 }
9458 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9459 ordinal: 214344082539672664,
9460 error,
9461 }),
9462 }
9463 }
9464
9465 ordinal => {
9466 handler.on_unknown_interaction(ordinal).await;
9467 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9468 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9469 } else {
9470 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
9471 ordinal,
9472 flexibility,
9473 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
9474 )
9475 .expect("encoding a framework error should never fail")
9476 .await?;
9477 Ok(())
9478 }
9479 }
9480 }
9481 }
9482}
9483
9484impl<___T> IntrospectorClientHandler<___T> for ::fidl_next::IgnoreEvents
9485where
9486 ___T: ::fidl_next::Transport,
9487{
9488 async fn on_unknown_interaction(&mut self, _: u64) {}
9489}
9490
9491impl<___H, ___T> IntrospectorLocalClientHandler<___T> for ::fidl_next::Local<___H>
9492where
9493 ___H: IntrospectorClientHandler<___T>,
9494 ___T: ::fidl_next::Transport,
9495{
9496 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9497 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9498 }
9499}
9500
9501impl<___H, ___T> IntrospectorLocalServerHandler<___T> for ::fidl_next::Local<___H>
9502where
9503 ___H: IntrospectorServerHandler<___T>,
9504 ___T: ::fidl_next::Transport,
9505{
9506 async fn get_moniker(
9507 &mut self,
9508
9509 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9510
9511 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9512 ) {
9513 ___H::get_moniker(&mut self.0, request, responder).await
9514 }
9515
9516 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9517 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9518 }
9519}
9520
9521#[doc = " Protocol for performing namespace operations.\n"]
9523#[derive(PartialEq, Debug)]
9524pub struct Namespace;
9525
9526impl ::fidl_next::Discoverable for Namespace {
9527 const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
9528}
9529
9530#[cfg(target_os = "fuchsia")]
9531impl ::fidl_next::HasTransport for Namespace {
9532 type Transport = ::fidl_next::fuchsia::zx::Channel;
9533}
9534
9535pub mod namespace {
9536 pub mod prelude {
9537 pub use crate::{
9538 Namespace, NamespaceClientHandler, NamespaceLocalClientHandler,
9539 NamespaceLocalServerHandler, NamespaceServerHandler, namespace,
9540 };
9541
9542 pub use crate::natural::NamespaceCreate2Request;
9543
9544 pub use crate::natural::NamespaceCreateRequest;
9545
9546 pub use crate::natural::NamespaceError;
9547
9548 pub use crate::natural::NamespaceCreate2Response;
9549
9550 pub use crate::natural::NamespaceCreateResponse;
9551 }
9552
9553 pub struct Create;
9554
9555 impl ::fidl_next::Method for Create {
9556 const ORDINAL: u64 = 4839678630846501113;
9557 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9558 ::fidl_next::protocol::Flexibility::Flexible;
9559
9560 type Protocol = crate::Namespace;
9561
9562 type Request = crate::wire::NamespaceCreateRequest<'static>;
9563 }
9564
9565 impl ::fidl_next::TwoWayMethod for Create {
9566 type Response = ::fidl_next::wire::FlexibleResult<
9567 'static,
9568 crate::wire::NamespaceCreateResponse<'static>,
9569 crate::wire::NamespaceError,
9570 >;
9571 }
9572
9573 impl<___R> ::fidl_next::Respond<___R> for Create {
9574 type Output = ::fidl_next::FlexibleResult<
9575 crate::generic::NamespaceCreateResponse<___R>,
9576 ::fidl_next::util::Never,
9577 >;
9578
9579 fn respond(response: ___R) -> Self::Output {
9580 ::fidl_next::FlexibleResult::Ok(crate::generic::NamespaceCreateResponse {
9581 entries: response,
9582 })
9583 }
9584 }
9585
9586 impl<___R> ::fidl_next::RespondErr<___R> for Create {
9587 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9588
9589 fn respond_err(response: ___R) -> Self::Output {
9590 ::fidl_next::FlexibleResult::Err(response)
9591 }
9592 }
9593
9594 pub struct Create2;
9595
9596 impl ::fidl_next::Method for Create2 {
9597 const ORDINAL: u64 = 7375388463768777553;
9598 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9599 ::fidl_next::protocol::Flexibility::Flexible;
9600
9601 type Protocol = crate::Namespace;
9602
9603 type Request = crate::wire::NamespaceCreate2Request<'static>;
9604 }
9605
9606 impl ::fidl_next::TwoWayMethod for Create2 {
9607 type Response = ::fidl_next::wire::FlexibleResult<
9608 'static,
9609 crate::wire::NamespaceCreate2Response<'static>,
9610 crate::wire::NamespaceError,
9611 >;
9612 }
9613
9614 impl<___R> ::fidl_next::Respond<___R> for Create2 {
9615 type Output = ::fidl_next::FlexibleResult<
9616 crate::generic::NamespaceCreate2Response<___R>,
9617 ::fidl_next::util::Never,
9618 >;
9619
9620 fn respond(response: ___R) -> Self::Output {
9621 ::fidl_next::FlexibleResult::Ok(crate::generic::NamespaceCreate2Response {
9622 entries: response,
9623 })
9624 }
9625 }
9626
9627 impl<___R> ::fidl_next::RespondErr<___R> for Create2 {
9628 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9629
9630 fn respond_err(response: ___R) -> Self::Output {
9631 ::fidl_next::FlexibleResult::Err(response)
9632 }
9633 }
9634
9635 mod ___detail {
9636 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Namespace
9637 where
9638 ___T: ::fidl_next::Transport,
9639 {
9640 type Client = NamespaceClient<___T>;
9641 type Server = NamespaceServer<___T>;
9642 }
9643
9644 #[repr(transparent)]
9646 pub struct NamespaceClient<___T: ::fidl_next::Transport> {
9647 #[allow(dead_code)]
9648 client: ::fidl_next::protocol::Client<___T>,
9649 }
9650
9651 impl<___T> NamespaceClient<___T>
9652 where
9653 ___T: ::fidl_next::Transport,
9654 {
9655 pub fn create(
9656 &self,
9657
9658 entries: impl ::fidl_next::Encode<
9659 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
9660 <___T as ::fidl_next::Transport>::SendBuffer,
9661 >,
9662 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9663 where
9664 <___T as ::fidl_next::Transport>::SendBuffer:
9665 ::fidl_next::encoder::InternalHandleEncoder,
9666 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9667 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9668 {
9669 self.create_with(crate::generic::NamespaceCreateRequest { entries })
9670 }
9671
9672 pub fn create_with<___R>(
9673 &self,
9674 request: ___R,
9675 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9676 where
9677 ___R: ::fidl_next::Encode<
9678 crate::wire::NamespaceCreateRequest<'static>,
9679 <___T as ::fidl_next::Transport>::SendBuffer,
9680 >,
9681 {
9682 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9683 4839678630846501113,
9684 <super::Create as ::fidl_next::Method>::FLEXIBILITY,
9685 request,
9686 ))
9687 }
9688
9689 pub fn create2(
9690 &self,
9691
9692 entries: impl ::fidl_next::Encode<
9693 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
9694 <___T as ::fidl_next::Transport>::SendBuffer,
9695 >,
9696 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9697 where
9698 <___T as ::fidl_next::Transport>::SendBuffer:
9699 ::fidl_next::encoder::InternalHandleEncoder,
9700 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9701 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9702 {
9703 self.create2_with(crate::generic::NamespaceCreate2Request { entries })
9704 }
9705
9706 pub fn create2_with<___R>(
9707 &self,
9708 request: ___R,
9709 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9710 where
9711 ___R: ::fidl_next::Encode<
9712 crate::wire::NamespaceCreate2Request<'static>,
9713 <___T as ::fidl_next::Transport>::SendBuffer,
9714 >,
9715 {
9716 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9717 7375388463768777553,
9718 <super::Create2 as ::fidl_next::Method>::FLEXIBILITY,
9719 request,
9720 ))
9721 }
9722 }
9723
9724 #[repr(transparent)]
9726 pub struct NamespaceServer<___T: ::fidl_next::Transport> {
9727 server: ::fidl_next::protocol::Server<___T>,
9728 }
9729
9730 impl<___T> NamespaceServer<___T> where ___T: ::fidl_next::Transport {}
9731 }
9732}
9733
9734#[diagnostic::on_unimplemented(
9735 note = "If {Self} implements the non-local NamespaceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9736)]
9737
9738pub trait NamespaceLocalClientHandler<
9742 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9743 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9744>
9745{
9746 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9747 ::core::future::ready(())
9748 }
9749}
9750
9751impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Namespace
9752where
9753 ___H: NamespaceLocalClientHandler<___T>,
9754 ___T: ::fidl_next::Transport,
9755{
9756 async fn on_event(
9757 handler: &mut ___H,
9758 ordinal: u64,
9759 flexibility: ::fidl_next::protocol::Flexibility,
9760 body: ::fidl_next::Body<___T>,
9761 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9762 match ordinal {
9763 ordinal => {
9764 handler.on_unknown_interaction(ordinal).await;
9765 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9766 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9767 } else {
9768 Ok(())
9769 }
9770 }
9771 }
9772 }
9773}
9774
9775#[diagnostic::on_unimplemented(
9776 note = "If {Self} implements the non-local NamespaceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9777)]
9778
9779pub trait NamespaceLocalServerHandler<
9783 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9784 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9785>
9786{
9787 fn create(
9788 &mut self,
9789
9790 request: ::fidl_next::Request<namespace::Create, ___T>,
9791
9792 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9793 ) -> impl ::core::future::Future<Output = ()>;
9794
9795 fn create2(
9796 &mut self,
9797
9798 request: ::fidl_next::Request<namespace::Create2, ___T>,
9799
9800 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9801 ) -> impl ::core::future::Future<Output = ()>;
9802
9803 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9804 ::core::future::ready(())
9805 }
9806}
9807
9808impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Namespace
9809where
9810 ___H: NamespaceLocalServerHandler<___T>,
9811 ___T: ::fidl_next::Transport,
9812 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9813 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9814 Constraint = (),
9815 >,
9816 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9817 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9818 Constraint = (),
9819 >,
9820{
9821 async fn on_one_way(
9822 handler: &mut ___H,
9823 ordinal: u64,
9824 flexibility: ::fidl_next::protocol::Flexibility,
9825 body: ::fidl_next::Body<___T>,
9826 ) -> ::core::result::Result<
9827 (),
9828 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9829 > {
9830 match ordinal {
9831 ordinal => {
9832 handler.on_unknown_interaction(ordinal).await;
9833 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9834 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9835 } else {
9836 Ok(())
9837 }
9838 }
9839 }
9840 }
9841
9842 async fn on_two_way(
9843 handler: &mut ___H,
9844 ordinal: u64,
9845 flexibility: ::fidl_next::protocol::Flexibility,
9846 body: ::fidl_next::Body<___T>,
9847 responder: ::fidl_next::protocol::Responder<___T>,
9848 ) -> ::core::result::Result<
9849 (),
9850 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9851 > {
9852 match ordinal {
9853 4839678630846501113 => {
9854 let responder = ::fidl_next::Responder::from_untyped(responder);
9855
9856 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9857 Ok(decoded) => {
9858 handler
9859 .create(::fidl_next::Request::from_decoded(decoded), responder)
9860 .await;
9861 Ok(())
9862 }
9863 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9864 ordinal: 4839678630846501113,
9865 error,
9866 }),
9867 }
9868 }
9869
9870 7375388463768777553 => {
9871 let responder = ::fidl_next::Responder::from_untyped(responder);
9872
9873 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9874 Ok(decoded) => {
9875 handler
9876 .create2(::fidl_next::Request::from_decoded(decoded), responder)
9877 .await;
9878 Ok(())
9879 }
9880 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9881 ordinal: 7375388463768777553,
9882 error,
9883 }),
9884 }
9885 }
9886
9887 ordinal => {
9888 handler.on_unknown_interaction(ordinal).await;
9889 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9890 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9891 } else {
9892 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
9893 ordinal,
9894 flexibility,
9895 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
9896 )
9897 .expect("encoding a framework error should never fail")
9898 .await?;
9899 Ok(())
9900 }
9901 }
9902 }
9903 }
9904}
9905
9906pub trait NamespaceClientHandler<
9910 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9911 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9912>
9913{
9914 fn on_unknown_interaction(
9915 &mut self,
9916 ordinal: u64,
9917 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9918 ::core::future::ready(())
9919 }
9920}
9921
9922impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Namespace
9923where
9924 ___H: NamespaceClientHandler<___T> + ::core::marker::Send,
9925 ___T: ::fidl_next::Transport,
9926{
9927 async fn on_event(
9928 handler: &mut ___H,
9929 ordinal: u64,
9930 flexibility: ::fidl_next::protocol::Flexibility,
9931 body: ::fidl_next::Body<___T>,
9932 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9933 match ordinal {
9934 ordinal => {
9935 handler.on_unknown_interaction(ordinal).await;
9936 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9937 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9938 } else {
9939 Ok(())
9940 }
9941 }
9942 }
9943 }
9944}
9945
9946pub trait NamespaceServerHandler<
9950 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9951 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9952>
9953{
9954 fn create(
9955 &mut self,
9956
9957 request: ::fidl_next::Request<namespace::Create, ___T>,
9958
9959 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9960 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9961
9962 fn create2(
9963 &mut self,
9964
9965 request: ::fidl_next::Request<namespace::Create2, ___T>,
9966
9967 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9968 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9969
9970 fn on_unknown_interaction(
9971 &mut self,
9972 ordinal: u64,
9973 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9974 ::core::future::ready(())
9975 }
9976}
9977
9978impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Namespace
9979where
9980 ___H: NamespaceServerHandler<___T> + ::core::marker::Send,
9981 ___T: ::fidl_next::Transport,
9982 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9983 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9984 Constraint = (),
9985 >,
9986 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9987 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9988 Constraint = (),
9989 >,
9990{
9991 async fn on_one_way(
9992 handler: &mut ___H,
9993 ordinal: u64,
9994 flexibility: ::fidl_next::protocol::Flexibility,
9995 body: ::fidl_next::Body<___T>,
9996 ) -> ::core::result::Result<
9997 (),
9998 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9999 > {
10000 match ordinal {
10001 ordinal => {
10002 handler.on_unknown_interaction(ordinal).await;
10003 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10004 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10005 } else {
10006 Ok(())
10007 }
10008 }
10009 }
10010 }
10011
10012 async fn on_two_way(
10013 handler: &mut ___H,
10014 ordinal: u64,
10015 flexibility: ::fidl_next::protocol::Flexibility,
10016 body: ::fidl_next::Body<___T>,
10017 responder: ::fidl_next::protocol::Responder<___T>,
10018 ) -> ::core::result::Result<
10019 (),
10020 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10021 > {
10022 match ordinal {
10023 4839678630846501113 => {
10024 let responder = ::fidl_next::Responder::from_untyped(responder);
10025
10026 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10027 Ok(decoded) => {
10028 handler
10029 .create(::fidl_next::Request::from_decoded(decoded), responder)
10030 .await;
10031 Ok(())
10032 }
10033 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10034 ordinal: 4839678630846501113,
10035 error,
10036 }),
10037 }
10038 }
10039
10040 7375388463768777553 => {
10041 let responder = ::fidl_next::Responder::from_untyped(responder);
10042
10043 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10044 Ok(decoded) => {
10045 handler
10046 .create2(::fidl_next::Request::from_decoded(decoded), responder)
10047 .await;
10048 Ok(())
10049 }
10050 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10051 ordinal: 7375388463768777553,
10052 error,
10053 }),
10054 }
10055 }
10056
10057 ordinal => {
10058 handler.on_unknown_interaction(ordinal).await;
10059 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
10060 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10061 } else {
10062 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
10063 ordinal,
10064 flexibility,
10065 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
10066 )
10067 .expect("encoding a framework error should never fail")
10068 .await?;
10069 Ok(())
10070 }
10071 }
10072 }
10073 }
10074}
10075
10076impl<___T> NamespaceClientHandler<___T> for ::fidl_next::IgnoreEvents
10077where
10078 ___T: ::fidl_next::Transport,
10079{
10080 async fn on_unknown_interaction(&mut self, _: u64) {}
10081}
10082
10083impl<___H, ___T> NamespaceLocalClientHandler<___T> for ::fidl_next::Local<___H>
10084where
10085 ___H: NamespaceClientHandler<___T>,
10086 ___T: ::fidl_next::Transport,
10087{
10088 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10089 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10090 }
10091}
10092
10093impl<___H, ___T> NamespaceLocalServerHandler<___T> for ::fidl_next::Local<___H>
10094where
10095 ___H: NamespaceServerHandler<___T>,
10096 ___T: ::fidl_next::Transport,
10097{
10098 async fn create(
10099 &mut self,
10100
10101 request: ::fidl_next::Request<namespace::Create, ___T>,
10102
10103 responder: ::fidl_next::Responder<namespace::Create, ___T>,
10104 ) {
10105 ___H::create(&mut self.0, request, responder).await
10106 }
10107
10108 async fn create2(
10109 &mut self,
10110
10111 request: ::fidl_next::Request<namespace::Create2, ___T>,
10112
10113 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
10114 ) {
10115 ___H::create2(&mut self.0, request, responder).await
10116 }
10117
10118 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10119 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10120 }
10121}
10122
10123#[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"]
10125#[derive(PartialEq, Debug)]
10126pub struct Realm;
10127
10128impl ::fidl_next::Discoverable for Realm {
10129 const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
10130}
10131
10132#[cfg(target_os = "fuchsia")]
10133impl ::fidl_next::HasTransport for Realm {
10134 type Transport = ::fidl_next::fuchsia::zx::Channel;
10135}
10136
10137pub mod realm {
10138 pub mod prelude {
10139 pub use crate::{
10140 Realm, RealmClientHandler, RealmLocalClientHandler, RealmLocalServerHandler,
10141 RealmServerHandler, realm,
10142 };
10143
10144 pub use crate::natural::Error;
10145
10146 pub use crate::natural::RealmCreateChildRequest;
10147
10148 pub use crate::natural::RealmDestroyChildRequest;
10149
10150 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
10151
10152 pub use crate::natural::RealmGetChildOutputDictionaryRequest;
10153
10154 pub use crate::natural::RealmListChildrenRequest;
10155
10156 pub use crate::natural::RealmOpenControllerRequest;
10157
10158 pub use crate::natural::RealmOpenExposedDirRequest;
10159
10160 pub use crate::natural::RealmCreateChildResponse;
10161
10162 pub use crate::natural::RealmDestroyChildResponse;
10163
10164 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
10165
10166 pub use crate::natural::RealmGetChildOutputDictionaryResponse;
10167
10168 pub use crate::natural::RealmGetResolvedInfoResponse;
10169
10170 pub use crate::natural::RealmListChildrenResponse;
10171
10172 pub use crate::natural::RealmOpenControllerResponse;
10173
10174 pub use crate::natural::RealmOpenExposedDirResponse;
10175 }
10176
10177 pub struct OpenController;
10178
10179 impl ::fidl_next::Method for OpenController {
10180 const ORDINAL: u64 = 8165227925828473216;
10181 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10182 ::fidl_next::protocol::Flexibility::Strict;
10183
10184 type Protocol = crate::Realm;
10185
10186 type Request = crate::wire::RealmOpenControllerRequest<'static>;
10187 }
10188
10189 impl ::fidl_next::TwoWayMethod for OpenController {
10190 type Response = ::fidl_next::wire::Result<
10191 'static,
10192 crate::wire::RealmOpenControllerResponse,
10193 crate::wire::Error,
10194 >;
10195 }
10196
10197 impl<___R> ::fidl_next::Respond<___R> for OpenController {
10198 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10199
10200 fn respond(response: ___R) -> Self::Output {
10201 ::core::result::Result::Ok(response)
10202 }
10203 }
10204
10205 impl<___R> ::fidl_next::RespondErr<___R> for OpenController {
10206 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10207
10208 fn respond_err(response: ___R) -> Self::Output {
10209 ::core::result::Result::Err(response)
10210 }
10211 }
10212
10213 pub struct OpenExposedDir;
10214
10215 impl ::fidl_next::Method for OpenExposedDir {
10216 const ORDINAL: u64 = 9194435320863127852;
10217 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10218 ::fidl_next::protocol::Flexibility::Strict;
10219
10220 type Protocol = crate::Realm;
10221
10222 type Request = crate::wire::RealmOpenExposedDirRequest<'static>;
10223 }
10224
10225 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
10226 type Response = ::fidl_next::wire::Result<
10227 'static,
10228 crate::wire::RealmOpenExposedDirResponse,
10229 crate::wire::Error,
10230 >;
10231 }
10232
10233 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
10234 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10235
10236 fn respond(response: ___R) -> Self::Output {
10237 ::core::result::Result::Ok(response)
10238 }
10239 }
10240
10241 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
10242 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10243
10244 fn respond_err(response: ___R) -> Self::Output {
10245 ::core::result::Result::Err(response)
10246 }
10247 }
10248
10249 pub struct CreateChild;
10250
10251 impl ::fidl_next::Method for CreateChild {
10252 const ORDINAL: u64 = 4892190024503489888;
10253 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10254 ::fidl_next::protocol::Flexibility::Strict;
10255
10256 type Protocol = crate::Realm;
10257
10258 type Request = crate::wire::RealmCreateChildRequest<'static>;
10259 }
10260
10261 impl ::fidl_next::TwoWayMethod for CreateChild {
10262 type Response = ::fidl_next::wire::Result<
10263 'static,
10264 crate::wire::RealmCreateChildResponse,
10265 crate::wire::Error,
10266 >;
10267 }
10268
10269 impl<___R> ::fidl_next::Respond<___R> for CreateChild {
10270 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10271
10272 fn respond(response: ___R) -> Self::Output {
10273 ::core::result::Result::Ok(response)
10274 }
10275 }
10276
10277 impl<___R> ::fidl_next::RespondErr<___R> for CreateChild {
10278 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10279
10280 fn respond_err(response: ___R) -> Self::Output {
10281 ::core::result::Result::Err(response)
10282 }
10283 }
10284
10285 pub struct DestroyChild;
10286
10287 impl ::fidl_next::Method for DestroyChild {
10288 const ORDINAL: u64 = 8203529889988252194;
10289 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10290 ::fidl_next::protocol::Flexibility::Strict;
10291
10292 type Protocol = crate::Realm;
10293
10294 type Request = crate::wire::RealmDestroyChildRequest<'static>;
10295 }
10296
10297 impl ::fidl_next::TwoWayMethod for DestroyChild {
10298 type Response = ::fidl_next::wire::Result<
10299 'static,
10300 crate::wire::RealmDestroyChildResponse,
10301 crate::wire::Error,
10302 >;
10303 }
10304
10305 impl<___R> ::fidl_next::Respond<___R> for DestroyChild {
10306 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10307
10308 fn respond(response: ___R) -> Self::Output {
10309 ::core::result::Result::Ok(response)
10310 }
10311 }
10312
10313 impl<___R> ::fidl_next::RespondErr<___R> for DestroyChild {
10314 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10315
10316 fn respond_err(response: ___R) -> Self::Output {
10317 ::core::result::Result::Err(response)
10318 }
10319 }
10320
10321 pub struct ListChildren;
10322
10323 impl ::fidl_next::Method for ListChildren {
10324 const ORDINAL: u64 = 7532454435519185057;
10325 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10326 ::fidl_next::protocol::Flexibility::Strict;
10327
10328 type Protocol = crate::Realm;
10329
10330 type Request = crate::wire::RealmListChildrenRequest<'static>;
10331 }
10332
10333 impl ::fidl_next::TwoWayMethod for ListChildren {
10334 type Response = ::fidl_next::wire::Result<
10335 'static,
10336 crate::wire::RealmListChildrenResponse,
10337 crate::wire::Error,
10338 >;
10339 }
10340
10341 impl<___R> ::fidl_next::Respond<___R> for ListChildren {
10342 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10343
10344 fn respond(response: ___R) -> Self::Output {
10345 ::core::result::Result::Ok(response)
10346 }
10347 }
10348
10349 impl<___R> ::fidl_next::RespondErr<___R> for ListChildren {
10350 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10351
10352 fn respond_err(response: ___R) -> Self::Output {
10353 ::core::result::Result::Err(response)
10354 }
10355 }
10356
10357 pub struct GetResolvedInfo;
10358
10359 impl ::fidl_next::Method for GetResolvedInfo {
10360 const ORDINAL: u64 = 8308987710372188322;
10361 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10362 ::fidl_next::protocol::Flexibility::Strict;
10363
10364 type Protocol = crate::Realm;
10365
10366 type Request = ::fidl_next::wire::EmptyMessageBody;
10367 }
10368
10369 impl ::fidl_next::TwoWayMethod for GetResolvedInfo {
10370 type Response = ::fidl_next::wire::Result<
10371 'static,
10372 crate::wire::RealmGetResolvedInfoResponse<'static>,
10373 crate::wire::Error,
10374 >;
10375 }
10376
10377 impl<___R> ::fidl_next::Respond<___R> for GetResolvedInfo {
10378 type Output = ::core::result::Result<
10379 crate::generic::RealmGetResolvedInfoResponse<___R>,
10380 ::fidl_next::util::Never,
10381 >;
10382
10383 fn respond(response: ___R) -> Self::Output {
10384 ::core::result::Result::Ok(crate::generic::RealmGetResolvedInfoResponse {
10385 resolved_info: response,
10386 })
10387 }
10388 }
10389
10390 impl<___R> ::fidl_next::RespondErr<___R> for GetResolvedInfo {
10391 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10392
10393 fn respond_err(response: ___R) -> Self::Output {
10394 ::core::result::Result::Err(response)
10395 }
10396 }
10397
10398 pub struct GetChildOutputDictionaryDeprecated;
10399
10400 impl ::fidl_next::Method for GetChildOutputDictionaryDeprecated {
10401 const ORDINAL: u64 = 4117516026351534948;
10402 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10403 ::fidl_next::protocol::Flexibility::Strict;
10404
10405 type Protocol = crate::Realm;
10406
10407 type Request = crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>;
10408 }
10409
10410 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionaryDeprecated {
10411 type Response = ::fidl_next::wire::Result<
10412 'static,
10413 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
10414 crate::wire::Error,
10415 >;
10416 }
10417
10418 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionaryDeprecated {
10419 type Output = ::core::result::Result<
10420 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse<___R>,
10421 ::fidl_next::util::Never,
10422 >;
10423
10424 fn respond(response: ___R) -> Self::Output {
10425 ::core::result::Result::Ok(
10426 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse {
10427 dictionary: response,
10428 },
10429 )
10430 }
10431 }
10432
10433 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionaryDeprecated {
10434 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10435
10436 fn respond_err(response: ___R) -> Self::Output {
10437 ::core::result::Result::Err(response)
10438 }
10439 }
10440
10441 pub struct GetChildOutputDictionary;
10442
10443 impl ::fidl_next::Method for GetChildOutputDictionary {
10444 const ORDINAL: u64 = 4781081784078915088;
10445 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10446 ::fidl_next::protocol::Flexibility::Strict;
10447
10448 type Protocol = crate::Realm;
10449
10450 type Request = crate::wire::RealmGetChildOutputDictionaryRequest<'static>;
10451 }
10452
10453 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionary {
10454 type Response = ::fidl_next::wire::Result<
10455 'static,
10456 crate::wire::RealmGetChildOutputDictionaryResponse,
10457 crate::wire::Error,
10458 >;
10459 }
10460
10461 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionary {
10462 type Output = ::core::result::Result<
10463 crate::generic::RealmGetChildOutputDictionaryResponse<___R>,
10464 ::fidl_next::util::Never,
10465 >;
10466
10467 fn respond(response: ___R) -> Self::Output {
10468 ::core::result::Result::Ok(crate::generic::RealmGetChildOutputDictionaryResponse {
10469 dictionary: response,
10470 })
10471 }
10472 }
10473
10474 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionary {
10475 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10476
10477 fn respond_err(response: ___R) -> Self::Output {
10478 ::core::result::Result::Err(response)
10479 }
10480 }
10481
10482 mod ___detail {
10483 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Realm
10484 where
10485 ___T: ::fidl_next::Transport,
10486 {
10487 type Client = RealmClient<___T>;
10488 type Server = RealmServer<___T>;
10489 }
10490
10491 #[repr(transparent)]
10493 pub struct RealmClient<___T: ::fidl_next::Transport> {
10494 #[allow(dead_code)]
10495 client: ::fidl_next::protocol::Client<___T>,
10496 }
10497
10498 impl<___T> RealmClient<___T>
10499 where
10500 ___T: ::fidl_next::Transport,
10501 {
10502 #[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"]
10503 pub fn open_controller(
10504 &self,
10505
10506 child: impl ::fidl_next::Encode<
10507 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10508 <___T as ::fidl_next::Transport>::SendBuffer,
10509 >,
10510
10511 controller: impl ::fidl_next::Encode<
10512 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
10513 <___T as ::fidl_next::Transport>::SendBuffer,
10514 >,
10515 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10516 where
10517 <___T as ::fidl_next::Transport>::SendBuffer:
10518 ::fidl_next::encoder::InternalHandleEncoder,
10519 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10520 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10521 {
10522 self.open_controller_with(crate::generic::RealmOpenControllerRequest {
10523 child,
10524
10525 controller,
10526 })
10527 }
10528
10529 #[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"]
10530 pub fn open_controller_with<___R>(
10531 &self,
10532 request: ___R,
10533 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10534 where
10535 ___R: ::fidl_next::Encode<
10536 crate::wire::RealmOpenControllerRequest<'static>,
10537 <___T as ::fidl_next::Transport>::SendBuffer,
10538 >,
10539 {
10540 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10541 8165227925828473216,
10542 <super::OpenController as ::fidl_next::Method>::FLEXIBILITY,
10543 request,
10544 ))
10545 }
10546
10547 #[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"]
10548 pub fn open_exposed_dir(
10549 &self,
10550
10551 child: impl ::fidl_next::Encode<
10552 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10553 <___T as ::fidl_next::Transport>::SendBuffer,
10554 >,
10555
10556 exposed_dir: impl ::fidl_next::Encode<
10557 ::fidl_next::ServerEnd<
10558 ::fidl_next_fuchsia_io::Directory,
10559 ::fidl_next::wire::fuchsia::Channel,
10560 >,
10561 <___T as ::fidl_next::Transport>::SendBuffer,
10562 >,
10563 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10564 where
10565 <___T as ::fidl_next::Transport>::SendBuffer:
10566 ::fidl_next::encoder::InternalHandleEncoder,
10567 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10568 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10569 {
10570 self.open_exposed_dir_with(crate::generic::RealmOpenExposedDirRequest {
10571 child,
10572
10573 exposed_dir,
10574 })
10575 }
10576
10577 #[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"]
10578 pub fn open_exposed_dir_with<___R>(
10579 &self,
10580 request: ___R,
10581 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10582 where
10583 ___R: ::fidl_next::Encode<
10584 crate::wire::RealmOpenExposedDirRequest<'static>,
10585 <___T as ::fidl_next::Transport>::SendBuffer,
10586 >,
10587 {
10588 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10589 9194435320863127852,
10590 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
10591 request,
10592 ))
10593 }
10594
10595 #[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"]
10596 pub fn create_child(
10597 &self,
10598
10599 collection: impl ::fidl_next::Encode<
10600 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10601 <___T as ::fidl_next::Transport>::SendBuffer,
10602 >,
10603
10604 decl: impl ::fidl_next::Encode<
10605 ::fidl_next_fuchsia_component_decl::wire::Child<'static>,
10606 <___T as ::fidl_next::Transport>::SendBuffer,
10607 >,
10608
10609 args: impl ::fidl_next::Encode<
10610 crate::wire::CreateChildArgs<'static>,
10611 <___T as ::fidl_next::Transport>::SendBuffer,
10612 >,
10613 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10614 where
10615 <___T as ::fidl_next::Transport>::SendBuffer:
10616 ::fidl_next::encoder::InternalHandleEncoder,
10617 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10618 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10619 {
10620 self.create_child_with(crate::generic::RealmCreateChildRequest {
10621 collection,
10622
10623 decl,
10624
10625 args,
10626 })
10627 }
10628
10629 #[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"]
10630 pub fn create_child_with<___R>(
10631 &self,
10632 request: ___R,
10633 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10634 where
10635 ___R: ::fidl_next::Encode<
10636 crate::wire::RealmCreateChildRequest<'static>,
10637 <___T as ::fidl_next::Transport>::SendBuffer,
10638 >,
10639 {
10640 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10641 4892190024503489888,
10642 <super::CreateChild as ::fidl_next::Method>::FLEXIBILITY,
10643 request,
10644 ))
10645 }
10646
10647 #[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"]
10648 pub fn destroy_child(
10649 &self,
10650
10651 child: impl ::fidl_next::Encode<
10652 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10653 <___T as ::fidl_next::Transport>::SendBuffer,
10654 >,
10655 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10656 where
10657 <___T as ::fidl_next::Transport>::SendBuffer:
10658 ::fidl_next::encoder::InternalHandleEncoder,
10659 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10660 {
10661 self.destroy_child_with(crate::generic::RealmDestroyChildRequest { child })
10662 }
10663
10664 #[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"]
10665 pub fn destroy_child_with<___R>(
10666 &self,
10667 request: ___R,
10668 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10669 where
10670 ___R: ::fidl_next::Encode<
10671 crate::wire::RealmDestroyChildRequest<'static>,
10672 <___T as ::fidl_next::Transport>::SendBuffer,
10673 >,
10674 {
10675 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10676 8203529889988252194,
10677 <super::DestroyChild as ::fidl_next::Method>::FLEXIBILITY,
10678 request,
10679 ))
10680 }
10681
10682 #[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"]
10683 pub fn list_children(
10684 &self,
10685
10686 collection: impl ::fidl_next::Encode<
10687 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10688 <___T as ::fidl_next::Transport>::SendBuffer,
10689 >,
10690
10691 iter: impl ::fidl_next::Encode<
10692 ::fidl_next::ServerEnd<
10693 crate::ChildIterator,
10694 ::fidl_next::wire::fuchsia::Channel,
10695 >,
10696 <___T as ::fidl_next::Transport>::SendBuffer,
10697 >,
10698 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10699 where
10700 <___T as ::fidl_next::Transport>::SendBuffer:
10701 ::fidl_next::encoder::InternalHandleEncoder,
10702 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10703 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10704 {
10705 self.list_children_with(crate::generic::RealmListChildrenRequest {
10706 collection,
10707
10708 iter,
10709 })
10710 }
10711
10712 #[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"]
10713 pub fn list_children_with<___R>(
10714 &self,
10715 request: ___R,
10716 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10717 where
10718 ___R: ::fidl_next::Encode<
10719 crate::wire::RealmListChildrenRequest<'static>,
10720 <___T as ::fidl_next::Transport>::SendBuffer,
10721 >,
10722 {
10723 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10724 7532454435519185057,
10725 <super::ListChildren as ::fidl_next::Method>::FLEXIBILITY,
10726 request,
10727 ))
10728 }
10729
10730 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10731 pub fn get_resolved_info(
10732 &self,
10733 ) -> ::fidl_next::TwoWayFuture<'_, super::GetResolvedInfo, ___T> {
10734 ::fidl_next::TwoWayFuture::from_untyped(
10735 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10736 8308987710372188322,
10737 <super::GetResolvedInfo as ::fidl_next::Method>::FLEXIBILITY,
10738 (),
10739 ),
10740 )
10741 }
10742
10743 pub fn get_child_output_dictionary_deprecated(
10744 &self,
10745
10746 child: impl ::fidl_next::Encode<
10747 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10748 <___T as ::fidl_next::Transport>::SendBuffer,
10749 >,
10750 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10751 where
10752 <___T as ::fidl_next::Transport>::SendBuffer:
10753 ::fidl_next::encoder::InternalHandleEncoder,
10754 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10755 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10756 {
10757 self.get_child_output_dictionary_deprecated_with(
10758 crate::generic::RealmGetChildOutputDictionaryDeprecatedRequest { child },
10759 )
10760 }
10761
10762 pub fn get_child_output_dictionary_deprecated_with<___R>(
10763 &self,
10764 request: ___R,
10765 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10766 where
10767 ___R: ::fidl_next::Encode<
10768 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
10769 <___T as ::fidl_next::Transport>::SendBuffer,
10770 >,
10771 {
10772 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10773 4117516026351534948,
10774 <super::GetChildOutputDictionaryDeprecated as ::fidl_next::Method>::FLEXIBILITY,
10775 request,
10776 ))
10777 }
10778
10779 #[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"]
10780 pub fn get_child_output_dictionary(
10781 &self,
10782
10783 child: impl ::fidl_next::Encode<
10784 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10785 <___T as ::fidl_next::Transport>::SendBuffer,
10786 >,
10787 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10788 where
10789 <___T as ::fidl_next::Transport>::SendBuffer:
10790 ::fidl_next::encoder::InternalHandleEncoder,
10791 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10792 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10793 {
10794 self.get_child_output_dictionary_with(
10795 crate::generic::RealmGetChildOutputDictionaryRequest { child },
10796 )
10797 }
10798
10799 #[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"]
10800 pub fn get_child_output_dictionary_with<___R>(
10801 &self,
10802 request: ___R,
10803 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10804 where
10805 ___R: ::fidl_next::Encode<
10806 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
10807 <___T as ::fidl_next::Transport>::SendBuffer,
10808 >,
10809 {
10810 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10811 4781081784078915088,
10812 <super::GetChildOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
10813 request,
10814 ))
10815 }
10816 }
10817
10818 #[repr(transparent)]
10820 pub struct RealmServer<___T: ::fidl_next::Transport> {
10821 server: ::fidl_next::protocol::Server<___T>,
10822 }
10823
10824 impl<___T> RealmServer<___T> where ___T: ::fidl_next::Transport {}
10825 }
10826}
10827
10828#[diagnostic::on_unimplemented(
10829 note = "If {Self} implements the non-local RealmClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
10830)]
10831
10832pub trait RealmLocalClientHandler<
10836 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10837 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10838>
10839{
10840}
10841
10842impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Realm
10843where
10844 ___H: RealmLocalClientHandler<___T>,
10845 ___T: ::fidl_next::Transport,
10846{
10847 async fn on_event(
10848 handler: &mut ___H,
10849 ordinal: u64,
10850 flexibility: ::fidl_next::protocol::Flexibility,
10851 body: ::fidl_next::Body<___T>,
10852 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10853 match ordinal {
10854 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10855 }
10856 }
10857}
10858
10859#[diagnostic::on_unimplemented(
10860 note = "If {Self} implements the non-local RealmServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
10861)]
10862
10863pub trait RealmLocalServerHandler<
10867 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10868 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10869>
10870{
10871 #[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"]
10872 fn open_controller(
10873 &mut self,
10874
10875 request: ::fidl_next::Request<realm::OpenController, ___T>,
10876
10877 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
10878 ) -> impl ::core::future::Future<Output = ()>;
10879
10880 #[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"]
10881 fn open_exposed_dir(
10882 &mut self,
10883
10884 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
10885
10886 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
10887 ) -> impl ::core::future::Future<Output = ()>;
10888
10889 #[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"]
10890 fn create_child(
10891 &mut self,
10892
10893 request: ::fidl_next::Request<realm::CreateChild, ___T>,
10894
10895 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
10896 ) -> impl ::core::future::Future<Output = ()>;
10897
10898 #[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"]
10899 fn destroy_child(
10900 &mut self,
10901
10902 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
10903
10904 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
10905 ) -> impl ::core::future::Future<Output = ()>;
10906
10907 #[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"]
10908 fn list_children(
10909 &mut self,
10910
10911 request: ::fidl_next::Request<realm::ListChildren, ___T>,
10912
10913 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
10914 ) -> impl ::core::future::Future<Output = ()>;
10915
10916 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10917 fn get_resolved_info(
10918 &mut self,
10919
10920 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
10921 ) -> impl ::core::future::Future<Output = ()>;
10922
10923 fn get_child_output_dictionary_deprecated(
10924 &mut self,
10925
10926 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
10927
10928 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
10929 ) -> impl ::core::future::Future<Output = ()>;
10930
10931 #[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"]
10932 fn get_child_output_dictionary(
10933 &mut self,
10934
10935 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
10936
10937 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
10938 ) -> impl ::core::future::Future<Output = ()>;
10939}
10940
10941impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Realm
10942where
10943 ___H: RealmLocalServerHandler<___T>,
10944 ___T: ::fidl_next::Transport,
10945 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
10946 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10947 Constraint = (),
10948 >,
10949 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
10950 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10951 Constraint = (),
10952 >,
10953 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
10954 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10955 Constraint = (),
10956 >,
10957 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
10958 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10959 Constraint = (),
10960 >,
10961 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
10962 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10963 Constraint = (),
10964 >,
10965 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
10966 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10967 Constraint = (),
10968 >,
10969 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
10970 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10971 Constraint = (),
10972 >,
10973{
10974 async fn on_one_way(
10975 handler: &mut ___H,
10976 ordinal: u64,
10977 flexibility: ::fidl_next::protocol::Flexibility,
10978 body: ::fidl_next::Body<___T>,
10979 ) -> ::core::result::Result<
10980 (),
10981 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10982 > {
10983 match ordinal {
10984 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10985 }
10986 }
10987
10988 async fn on_two_way(
10989 handler: &mut ___H,
10990 ordinal: u64,
10991 flexibility: ::fidl_next::protocol::Flexibility,
10992 body: ::fidl_next::Body<___T>,
10993 responder: ::fidl_next::protocol::Responder<___T>,
10994 ) -> ::core::result::Result<
10995 (),
10996 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10997 > {
10998 match ordinal {
10999 8165227925828473216 => {
11000 let responder = ::fidl_next::Responder::from_untyped(responder);
11001
11002 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11003 Ok(decoded) => {
11004 handler
11005 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11006 .await;
11007 Ok(())
11008 }
11009 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11010 ordinal: 8165227925828473216,
11011 error,
11012 }),
11013 }
11014 }
11015
11016 9194435320863127852 => {
11017 let responder = ::fidl_next::Responder::from_untyped(responder);
11018
11019 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11020 Ok(decoded) => {
11021 handler
11022 .open_exposed_dir(
11023 ::fidl_next::Request::from_decoded(decoded),
11024 responder,
11025 )
11026 .await;
11027 Ok(())
11028 }
11029 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11030 ordinal: 9194435320863127852,
11031 error,
11032 }),
11033 }
11034 }
11035
11036 4892190024503489888 => {
11037 let responder = ::fidl_next::Responder::from_untyped(responder);
11038
11039 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11040 Ok(decoded) => {
11041 handler
11042 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11043 .await;
11044 Ok(())
11045 }
11046 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11047 ordinal: 4892190024503489888,
11048 error,
11049 }),
11050 }
11051 }
11052
11053 8203529889988252194 => {
11054 let responder = ::fidl_next::Responder::from_untyped(responder);
11055
11056 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11057 Ok(decoded) => {
11058 handler
11059 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11060 .await;
11061 Ok(())
11062 }
11063 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11064 ordinal: 8203529889988252194,
11065 error,
11066 }),
11067 }
11068 }
11069
11070 7532454435519185057 => {
11071 let responder = ::fidl_next::Responder::from_untyped(responder);
11072
11073 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11074 Ok(decoded) => {
11075 handler
11076 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11077 .await;
11078 Ok(())
11079 }
11080 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11081 ordinal: 7532454435519185057,
11082 error,
11083 }),
11084 }
11085 }
11086
11087 8308987710372188322 => {
11088 let responder = ::fidl_next::Responder::from_untyped(responder);
11089
11090 handler.get_resolved_info(responder).await;
11091 Ok(())
11092 }
11093
11094 4117516026351534948 => {
11095 let responder = ::fidl_next::Responder::from_untyped(responder);
11096
11097 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11098 Ok(decoded) => {
11099 handler
11100 .get_child_output_dictionary_deprecated(
11101 ::fidl_next::Request::from_decoded(decoded),
11102 responder,
11103 )
11104 .await;
11105 Ok(())
11106 }
11107 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11108 ordinal: 4117516026351534948,
11109 error,
11110 }),
11111 }
11112 }
11113
11114 4781081784078915088 => {
11115 let responder = ::fidl_next::Responder::from_untyped(responder);
11116
11117 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11118 Ok(decoded) => {
11119 handler
11120 .get_child_output_dictionary(
11121 ::fidl_next::Request::from_decoded(decoded),
11122 responder,
11123 )
11124 .await;
11125 Ok(())
11126 }
11127 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11128 ordinal: 4781081784078915088,
11129 error,
11130 }),
11131 }
11132 }
11133
11134 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11135 }
11136 }
11137}
11138
11139pub trait RealmClientHandler<
11143 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11144 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11145>
11146{
11147}
11148
11149impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Realm
11150where
11151 ___H: RealmClientHandler<___T> + ::core::marker::Send,
11152 ___T: ::fidl_next::Transport,
11153{
11154 async fn on_event(
11155 handler: &mut ___H,
11156 ordinal: u64,
11157 flexibility: ::fidl_next::protocol::Flexibility,
11158 body: ::fidl_next::Body<___T>,
11159 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11160 match ordinal {
11161 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11162 }
11163 }
11164}
11165
11166pub trait RealmServerHandler<
11170 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11171 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11172>
11173{
11174 #[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"]
11175 fn open_controller(
11176 &mut self,
11177
11178 request: ::fidl_next::Request<realm::OpenController, ___T>,
11179
11180 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11181 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11182
11183 #[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"]
11184 fn open_exposed_dir(
11185 &mut self,
11186
11187 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11188
11189 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11190 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11191
11192 #[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"]
11193 fn create_child(
11194 &mut self,
11195
11196 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11197
11198 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11199 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11200
11201 #[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"]
11202 fn destroy_child(
11203 &mut self,
11204
11205 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11206
11207 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11208 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11209
11210 #[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"]
11211 fn list_children(
11212 &mut self,
11213
11214 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11215
11216 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11217 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11218
11219 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11220 fn get_resolved_info(
11221 &mut self,
11222
11223 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11224 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11225
11226 fn get_child_output_dictionary_deprecated(
11227 &mut self,
11228
11229 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11230
11231 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11232 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11233
11234 #[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"]
11235 fn get_child_output_dictionary(
11236 &mut self,
11237
11238 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11239
11240 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11241 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11242}
11243
11244impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Realm
11245where
11246 ___H: RealmServerHandler<___T> + ::core::marker::Send,
11247 ___T: ::fidl_next::Transport,
11248 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
11249 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11250 Constraint = (),
11251 >,
11252 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
11253 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11254 Constraint = (),
11255 >,
11256 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
11257 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11258 Constraint = (),
11259 >,
11260 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
11261 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11262 Constraint = (),
11263 >,
11264 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
11265 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11266 Constraint = (),
11267 >,
11268 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
11269 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11270 Constraint = (),
11271 >,
11272 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
11273 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11274 Constraint = (),
11275 >,
11276{
11277 async fn on_one_way(
11278 handler: &mut ___H,
11279 ordinal: u64,
11280 flexibility: ::fidl_next::protocol::Flexibility,
11281 body: ::fidl_next::Body<___T>,
11282 ) -> ::core::result::Result<
11283 (),
11284 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11285 > {
11286 match ordinal {
11287 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11288 }
11289 }
11290
11291 async fn on_two_way(
11292 handler: &mut ___H,
11293 ordinal: u64,
11294 flexibility: ::fidl_next::protocol::Flexibility,
11295 body: ::fidl_next::Body<___T>,
11296 responder: ::fidl_next::protocol::Responder<___T>,
11297 ) -> ::core::result::Result<
11298 (),
11299 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11300 > {
11301 match ordinal {
11302 8165227925828473216 => {
11303 let responder = ::fidl_next::Responder::from_untyped(responder);
11304
11305 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11306 Ok(decoded) => {
11307 handler
11308 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11309 .await;
11310 Ok(())
11311 }
11312 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11313 ordinal: 8165227925828473216,
11314 error,
11315 }),
11316 }
11317 }
11318
11319 9194435320863127852 => {
11320 let responder = ::fidl_next::Responder::from_untyped(responder);
11321
11322 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11323 Ok(decoded) => {
11324 handler
11325 .open_exposed_dir(
11326 ::fidl_next::Request::from_decoded(decoded),
11327 responder,
11328 )
11329 .await;
11330 Ok(())
11331 }
11332 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11333 ordinal: 9194435320863127852,
11334 error,
11335 }),
11336 }
11337 }
11338
11339 4892190024503489888 => {
11340 let responder = ::fidl_next::Responder::from_untyped(responder);
11341
11342 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11343 Ok(decoded) => {
11344 handler
11345 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11346 .await;
11347 Ok(())
11348 }
11349 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11350 ordinal: 4892190024503489888,
11351 error,
11352 }),
11353 }
11354 }
11355
11356 8203529889988252194 => {
11357 let responder = ::fidl_next::Responder::from_untyped(responder);
11358
11359 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11360 Ok(decoded) => {
11361 handler
11362 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11363 .await;
11364 Ok(())
11365 }
11366 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11367 ordinal: 8203529889988252194,
11368 error,
11369 }),
11370 }
11371 }
11372
11373 7532454435519185057 => {
11374 let responder = ::fidl_next::Responder::from_untyped(responder);
11375
11376 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11377 Ok(decoded) => {
11378 handler
11379 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11380 .await;
11381 Ok(())
11382 }
11383 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11384 ordinal: 7532454435519185057,
11385 error,
11386 }),
11387 }
11388 }
11389
11390 8308987710372188322 => {
11391 let responder = ::fidl_next::Responder::from_untyped(responder);
11392
11393 handler.get_resolved_info(responder).await;
11394 Ok(())
11395 }
11396
11397 4117516026351534948 => {
11398 let responder = ::fidl_next::Responder::from_untyped(responder);
11399
11400 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11401 Ok(decoded) => {
11402 handler
11403 .get_child_output_dictionary_deprecated(
11404 ::fidl_next::Request::from_decoded(decoded),
11405 responder,
11406 )
11407 .await;
11408 Ok(())
11409 }
11410 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11411 ordinal: 4117516026351534948,
11412 error,
11413 }),
11414 }
11415 }
11416
11417 4781081784078915088 => {
11418 let responder = ::fidl_next::Responder::from_untyped(responder);
11419
11420 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11421 Ok(decoded) => {
11422 handler
11423 .get_child_output_dictionary(
11424 ::fidl_next::Request::from_decoded(decoded),
11425 responder,
11426 )
11427 .await;
11428 Ok(())
11429 }
11430 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11431 ordinal: 4781081784078915088,
11432 error,
11433 }),
11434 }
11435 }
11436
11437 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11438 }
11439 }
11440}
11441
11442impl<___T> RealmClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
11443
11444impl<___H, ___T> RealmLocalClientHandler<___T> for ::fidl_next::Local<___H>
11445where
11446 ___H: RealmClientHandler<___T>,
11447 ___T: ::fidl_next::Transport,
11448{
11449}
11450
11451impl<___H, ___T> RealmLocalServerHandler<___T> for ::fidl_next::Local<___H>
11452where
11453 ___H: RealmServerHandler<___T>,
11454 ___T: ::fidl_next::Transport,
11455{
11456 async fn open_controller(
11457 &mut self,
11458
11459 request: ::fidl_next::Request<realm::OpenController, ___T>,
11460
11461 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11462 ) {
11463 ___H::open_controller(&mut self.0, request, responder).await
11464 }
11465
11466 async fn open_exposed_dir(
11467 &mut self,
11468
11469 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11470
11471 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11472 ) {
11473 ___H::open_exposed_dir(&mut self.0, request, responder).await
11474 }
11475
11476 async fn create_child(
11477 &mut self,
11478
11479 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11480
11481 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11482 ) {
11483 ___H::create_child(&mut self.0, request, responder).await
11484 }
11485
11486 async fn destroy_child(
11487 &mut self,
11488
11489 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11490
11491 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11492 ) {
11493 ___H::destroy_child(&mut self.0, request, responder).await
11494 }
11495
11496 async fn list_children(
11497 &mut self,
11498
11499 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11500
11501 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11502 ) {
11503 ___H::list_children(&mut self.0, request, responder).await
11504 }
11505
11506 async fn get_resolved_info(
11507 &mut self,
11508
11509 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11510 ) {
11511 ___H::get_resolved_info(&mut self.0, responder).await
11512 }
11513
11514 async fn get_child_output_dictionary_deprecated(
11515 &mut self,
11516
11517 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11518
11519 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11520 ) {
11521 ___H::get_child_output_dictionary_deprecated(&mut self.0, request, responder).await
11522 }
11523
11524 async fn get_child_output_dictionary(
11525 &mut self,
11526
11527 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11528
11529 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11530 ) {
11531 ___H::get_child_output_dictionary(&mut self.0, request, responder).await
11532 }
11533}
11534
11535#[derive(PartialEq, Debug)]
11537pub struct StorageAdmin;
11538
11539impl ::fidl_next::Discoverable for StorageAdmin {
11540 const PROTOCOL_NAME: &'static str = "fuchsia.component.StorageAdmin";
11541}
11542
11543#[cfg(target_os = "fuchsia")]
11544impl ::fidl_next::HasTransport for StorageAdmin {
11545 type Transport = ::fidl_next::fuchsia::zx::Channel;
11546}
11547
11548pub mod storage_admin {
11549 pub mod prelude {
11550 pub use crate::{
11551 StorageAdmin, StorageAdminClientHandler, StorageAdminLocalClientHandler,
11552 StorageAdminLocalServerHandler, StorageAdminServerHandler, storage_admin,
11553 };
11554
11555 pub use crate::natural::DeletionError;
11556
11557 pub use crate::natural::Error;
11558
11559 pub use crate::natural::StatusError;
11560
11561 pub use crate::natural::StorageAdminDeleteComponentStorageRequest;
11562
11563 pub use crate::natural::StorageAdminListStorageInRealmRequest;
11564
11565 pub use crate::natural::StorageAdminOpenComponentStorageByIdRequest;
11566
11567 pub use crate::natural::StorageAdminOpenStorageRequest;
11568
11569 pub use crate::natural::StorageAdminDeleteAllStorageContentsResponse;
11570
11571 pub use crate::natural::StorageAdminDeleteComponentStorageResponse;
11572
11573 pub use crate::natural::StorageAdminListStorageInRealmResponse;
11574
11575 pub use crate::natural::StorageAdminOpenComponentStorageByIdResponse;
11576
11577 pub use crate::natural::StorageAdminOpenStorageResponse;
11578
11579 pub use crate::natural::StorageStatus;
11580 }
11581
11582 pub struct OpenStorage;
11583
11584 impl ::fidl_next::Method for OpenStorage {
11585 const ORDINAL: u64 = 7848267339832116087;
11586 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11587 ::fidl_next::protocol::Flexibility::Strict;
11588
11589 type Protocol = crate::StorageAdmin;
11590
11591 type Request = crate::wire::StorageAdminOpenStorageRequest<'static>;
11592 }
11593
11594 impl ::fidl_next::TwoWayMethod for OpenStorage {
11595 type Response = ::fidl_next::wire::Result<
11596 'static,
11597 crate::wire::StorageAdminOpenStorageResponse,
11598 crate::wire::Error,
11599 >;
11600 }
11601
11602 impl<___R> ::fidl_next::Respond<___R> for OpenStorage {
11603 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11604
11605 fn respond(response: ___R) -> Self::Output {
11606 ::core::result::Result::Ok(response)
11607 }
11608 }
11609
11610 impl<___R> ::fidl_next::RespondErr<___R> for OpenStorage {
11611 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11612
11613 fn respond_err(response: ___R) -> Self::Output {
11614 ::core::result::Result::Err(response)
11615 }
11616 }
11617
11618 pub struct ListStorageInRealm;
11619
11620 impl ::fidl_next::Method for ListStorageInRealm {
11621 const ORDINAL: u64 = 8525152599685368827;
11622 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11623 ::fidl_next::protocol::Flexibility::Strict;
11624
11625 type Protocol = crate::StorageAdmin;
11626
11627 type Request = crate::wire::StorageAdminListStorageInRealmRequest<'static>;
11628 }
11629
11630 impl ::fidl_next::TwoWayMethod for ListStorageInRealm {
11631 type Response = ::fidl_next::wire::Result<
11632 'static,
11633 crate::wire::StorageAdminListStorageInRealmResponse,
11634 crate::wire::Error,
11635 >;
11636 }
11637
11638 impl<___R> ::fidl_next::Respond<___R> for ListStorageInRealm {
11639 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11640
11641 fn respond(response: ___R) -> Self::Output {
11642 ::core::result::Result::Ok(response)
11643 }
11644 }
11645
11646 impl<___R> ::fidl_next::RespondErr<___R> for ListStorageInRealm {
11647 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11648
11649 fn respond_err(response: ___R) -> Self::Output {
11650 ::core::result::Result::Err(response)
11651 }
11652 }
11653
11654 pub struct OpenComponentStorageById;
11655
11656 impl ::fidl_next::Method for OpenComponentStorageById {
11657 const ORDINAL: u64 = 5188727505160068593;
11658 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11659 ::fidl_next::protocol::Flexibility::Strict;
11660
11661 type Protocol = crate::StorageAdmin;
11662
11663 type Request = crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>;
11664 }
11665
11666 impl ::fidl_next::TwoWayMethod for OpenComponentStorageById {
11667 type Response = ::fidl_next::wire::Result<
11668 'static,
11669 crate::wire::StorageAdminOpenComponentStorageByIdResponse,
11670 crate::wire::Error,
11671 >;
11672 }
11673
11674 impl<___R> ::fidl_next::Respond<___R> for OpenComponentStorageById {
11675 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11676
11677 fn respond(response: ___R) -> Self::Output {
11678 ::core::result::Result::Ok(response)
11679 }
11680 }
11681
11682 impl<___R> ::fidl_next::RespondErr<___R> for OpenComponentStorageById {
11683 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11684
11685 fn respond_err(response: ___R) -> Self::Output {
11686 ::core::result::Result::Err(response)
11687 }
11688 }
11689
11690 pub struct DeleteComponentStorage;
11691
11692 impl ::fidl_next::Method for DeleteComponentStorage {
11693 const ORDINAL: u64 = 1618975681517712474;
11694 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11695 ::fidl_next::protocol::Flexibility::Strict;
11696
11697 type Protocol = crate::StorageAdmin;
11698
11699 type Request = crate::wire::StorageAdminDeleteComponentStorageRequest<'static>;
11700 }
11701
11702 impl ::fidl_next::TwoWayMethod for DeleteComponentStorage {
11703 type Response = ::fidl_next::wire::Result<
11704 'static,
11705 crate::wire::StorageAdminDeleteComponentStorageResponse,
11706 crate::wire::Error,
11707 >;
11708 }
11709
11710 impl<___R> ::fidl_next::Respond<___R> for DeleteComponentStorage {
11711 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11712
11713 fn respond(response: ___R) -> Self::Output {
11714 ::core::result::Result::Ok(response)
11715 }
11716 }
11717
11718 impl<___R> ::fidl_next::RespondErr<___R> for DeleteComponentStorage {
11719 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11720
11721 fn respond_err(response: ___R) -> Self::Output {
11722 ::core::result::Result::Err(response)
11723 }
11724 }
11725
11726 pub struct GetStatus;
11727
11728 impl ::fidl_next::Method for GetStatus {
11729 const ORDINAL: u64 = 8586643915409794760;
11730 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11731 ::fidl_next::protocol::Flexibility::Strict;
11732
11733 type Protocol = crate::StorageAdmin;
11734
11735 type Request = ::fidl_next::wire::EmptyMessageBody;
11736 }
11737
11738 impl ::fidl_next::TwoWayMethod for GetStatus {
11739 type Response = ::fidl_next::wire::Result<
11740 'static,
11741 crate::wire::StorageStatus<'static>,
11742 crate::wire::StatusError,
11743 >;
11744 }
11745
11746 impl<___R> ::fidl_next::Respond<___R> for GetStatus {
11747 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11748
11749 fn respond(response: ___R) -> Self::Output {
11750 ::core::result::Result::Ok(response)
11751 }
11752 }
11753
11754 impl<___R> ::fidl_next::RespondErr<___R> for GetStatus {
11755 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11756
11757 fn respond_err(response: ___R) -> Self::Output {
11758 ::core::result::Result::Err(response)
11759 }
11760 }
11761
11762 pub struct DeleteAllStorageContents;
11763
11764 impl ::fidl_next::Method for DeleteAllStorageContents {
11765 const ORDINAL: u64 = 3380374508900862683;
11766 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11767 ::fidl_next::protocol::Flexibility::Strict;
11768
11769 type Protocol = crate::StorageAdmin;
11770
11771 type Request = ::fidl_next::wire::EmptyMessageBody;
11772 }
11773
11774 impl ::fidl_next::TwoWayMethod for DeleteAllStorageContents {
11775 type Response = ::fidl_next::wire::Result<
11776 'static,
11777 crate::wire::StorageAdminDeleteAllStorageContentsResponse,
11778 crate::wire::DeletionError,
11779 >;
11780 }
11781
11782 impl<___R> ::fidl_next::Respond<___R> for DeleteAllStorageContents {
11783 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
11784
11785 fn respond(response: ___R) -> Self::Output {
11786 ::core::result::Result::Ok(response)
11787 }
11788 }
11789
11790 impl<___R> ::fidl_next::RespondErr<___R> for DeleteAllStorageContents {
11791 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
11792
11793 fn respond_err(response: ___R) -> Self::Output {
11794 ::core::result::Result::Err(response)
11795 }
11796 }
11797
11798 mod ___detail {
11799 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageAdmin
11800 where
11801 ___T: ::fidl_next::Transport,
11802 {
11803 type Client = StorageAdminClient<___T>;
11804 type Server = StorageAdminServer<___T>;
11805 }
11806
11807 #[repr(transparent)]
11809 pub struct StorageAdminClient<___T: ::fidl_next::Transport> {
11810 #[allow(dead_code)]
11811 client: ::fidl_next::protocol::Client<___T>,
11812 }
11813
11814 impl<___T> StorageAdminClient<___T>
11815 where
11816 ___T: ::fidl_next::Transport,
11817 {
11818 #[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"]
11819 pub fn open_storage(
11820 &self,
11821
11822 relative_moniker: impl ::fidl_next::Encode<
11823 ::fidl_next::wire::String<'static>,
11824 <___T as ::fidl_next::Transport>::SendBuffer,
11825 >,
11826
11827 object: impl ::fidl_next::Encode<
11828 ::fidl_next::ServerEnd<
11829 ::fidl_next_fuchsia_io::Node,
11830 ::fidl_next::wire::fuchsia::Channel,
11831 >,
11832 <___T as ::fidl_next::Transport>::SendBuffer,
11833 >,
11834 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
11835 where
11836 <___T as ::fidl_next::Transport>::SendBuffer:
11837 ::fidl_next::encoder::InternalHandleEncoder,
11838 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11839 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11840 {
11841 self.open_storage_with(crate::generic::StorageAdminOpenStorageRequest {
11842 relative_moniker,
11843
11844 object,
11845 })
11846 }
11847
11848 #[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"]
11849 pub fn open_storage_with<___R>(
11850 &self,
11851 request: ___R,
11852 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
11853 where
11854 ___R: ::fidl_next::Encode<
11855 crate::wire::StorageAdminOpenStorageRequest<'static>,
11856 <___T as ::fidl_next::Transport>::SendBuffer,
11857 >,
11858 {
11859 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11860 7848267339832116087,
11861 <super::OpenStorage as ::fidl_next::Method>::FLEXIBILITY,
11862 request,
11863 ))
11864 }
11865
11866 #[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"]
11867 pub fn list_storage_in_realm(
11868 &self,
11869
11870 relative_moniker: impl ::fidl_next::Encode<
11871 ::fidl_next::wire::String<'static>,
11872 <___T as ::fidl_next::Transport>::SendBuffer,
11873 >,
11874
11875 iterator: impl ::fidl_next::Encode<
11876 ::fidl_next::ServerEnd<
11877 crate::StorageIterator,
11878 ::fidl_next::wire::fuchsia::Channel,
11879 >,
11880 <___T as ::fidl_next::Transport>::SendBuffer,
11881 >,
11882 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
11883 where
11884 <___T as ::fidl_next::Transport>::SendBuffer:
11885 ::fidl_next::encoder::InternalHandleEncoder,
11886 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11887 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11888 {
11889 self.list_storage_in_realm_with(
11890 crate::generic::StorageAdminListStorageInRealmRequest {
11891 relative_moniker,
11892
11893 iterator,
11894 },
11895 )
11896 }
11897
11898 #[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"]
11899 pub fn list_storage_in_realm_with<___R>(
11900 &self,
11901 request: ___R,
11902 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
11903 where
11904 ___R: ::fidl_next::Encode<
11905 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
11906 <___T as ::fidl_next::Transport>::SendBuffer,
11907 >,
11908 {
11909 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11910 8525152599685368827,
11911 <super::ListStorageInRealm as ::fidl_next::Method>::FLEXIBILITY,
11912 request,
11913 ))
11914 }
11915
11916 #[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"]
11917 pub fn open_component_storage_by_id(
11918 &self,
11919
11920 id: impl ::fidl_next::Encode<
11921 ::fidl_next::wire::String<'static>,
11922 <___T as ::fidl_next::Transport>::SendBuffer,
11923 >,
11924
11925 object: impl ::fidl_next::Encode<
11926 ::fidl_next::ServerEnd<
11927 ::fidl_next_fuchsia_io::Node,
11928 ::fidl_next::wire::fuchsia::Channel,
11929 >,
11930 <___T as ::fidl_next::Transport>::SendBuffer,
11931 >,
11932 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
11933 where
11934 <___T as ::fidl_next::Transport>::SendBuffer:
11935 ::fidl_next::encoder::InternalHandleEncoder,
11936 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11937 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
11938 {
11939 self.open_component_storage_by_id_with(
11940 crate::generic::StorageAdminOpenComponentStorageByIdRequest { id, object },
11941 )
11942 }
11943
11944 #[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"]
11945 pub fn open_component_storage_by_id_with<___R>(
11946 &self,
11947 request: ___R,
11948 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
11949 where
11950 ___R: ::fidl_next::Encode<
11951 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
11952 <___T as ::fidl_next::Transport>::SendBuffer,
11953 >,
11954 {
11955 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11956 5188727505160068593,
11957 <super::OpenComponentStorageById as ::fidl_next::Method>::FLEXIBILITY,
11958 request,
11959 ))
11960 }
11961
11962 #[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"]
11963 pub fn delete_component_storage(
11964 &self,
11965
11966 relative_moniker: impl ::fidl_next::Encode<
11967 ::fidl_next::wire::String<'static>,
11968 <___T as ::fidl_next::Transport>::SendBuffer,
11969 >,
11970 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
11971 where
11972 <___T as ::fidl_next::Transport>::SendBuffer:
11973 ::fidl_next::encoder::InternalHandleEncoder,
11974 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
11975 {
11976 self.delete_component_storage_with(
11977 crate::generic::StorageAdminDeleteComponentStorageRequest { relative_moniker },
11978 )
11979 }
11980
11981 #[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"]
11982 pub fn delete_component_storage_with<___R>(
11983 &self,
11984 request: ___R,
11985 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
11986 where
11987 ___R: ::fidl_next::Encode<
11988 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
11989 <___T as ::fidl_next::Transport>::SendBuffer,
11990 >,
11991 {
11992 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
11993 1618975681517712474,
11994 <super::DeleteComponentStorage as ::fidl_next::Method>::FLEXIBILITY,
11995 request,
11996 ))
11997 }
11998
11999 #[doc = " Get the current status of the storage.\n"]
12000 pub fn get_status(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetStatus, ___T> {
12001 ::fidl_next::TwoWayFuture::from_untyped(
12002 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12003 8586643915409794760,
12004 <super::GetStatus as ::fidl_next::Method>::FLEXIBILITY,
12005 (),
12006 ),
12007 )
12008 }
12009
12010 #[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"]
12011 pub fn delete_all_storage_contents(
12012 &self,
12013 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteAllStorageContents, ___T> {
12014 ::fidl_next::TwoWayFuture::from_untyped(
12015 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12016 3380374508900862683,
12017 <super::DeleteAllStorageContents as ::fidl_next::Method>::FLEXIBILITY,
12018 (),
12019 ),
12020 )
12021 }
12022 }
12023
12024 #[repr(transparent)]
12026 pub struct StorageAdminServer<___T: ::fidl_next::Transport> {
12027 server: ::fidl_next::protocol::Server<___T>,
12028 }
12029
12030 impl<___T> StorageAdminServer<___T> where ___T: ::fidl_next::Transport {}
12031 }
12032}
12033
12034#[diagnostic::on_unimplemented(
12035 note = "If {Self} implements the non-local StorageAdminClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12036)]
12037
12038pub trait StorageAdminLocalClientHandler<
12042 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12043 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12044>
12045{
12046}
12047
12048impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageAdmin
12049where
12050 ___H: StorageAdminLocalClientHandler<___T>,
12051 ___T: ::fidl_next::Transport,
12052{
12053 async fn on_event(
12054 handler: &mut ___H,
12055 ordinal: u64,
12056 flexibility: ::fidl_next::protocol::Flexibility,
12057 body: ::fidl_next::Body<___T>,
12058 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12059 match ordinal {
12060 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12061 }
12062 }
12063}
12064
12065#[diagnostic::on_unimplemented(
12066 note = "If {Self} implements the non-local StorageAdminServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12067)]
12068
12069pub trait StorageAdminLocalServerHandler<
12073 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12074 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12075>
12076{
12077 #[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"]
12078 fn open_storage(
12079 &mut self,
12080
12081 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12082
12083 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12084 ) -> impl ::core::future::Future<Output = ()>;
12085
12086 #[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"]
12087 fn list_storage_in_realm(
12088 &mut self,
12089
12090 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12091
12092 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12093 ) -> impl ::core::future::Future<Output = ()>;
12094
12095 #[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"]
12096 fn open_component_storage_by_id(
12097 &mut self,
12098
12099 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12100
12101 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12102 ) -> impl ::core::future::Future<Output = ()>;
12103
12104 #[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"]
12105 fn delete_component_storage(
12106 &mut self,
12107
12108 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12109
12110 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12111 ) -> impl ::core::future::Future<Output = ()>;
12112
12113 #[doc = " Get the current status of the storage.\n"]
12114 fn get_status(
12115 &mut self,
12116
12117 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12118 ) -> impl ::core::future::Future<Output = ()>;
12119
12120 #[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"]
12121 fn delete_all_storage_contents(
12122 &mut self,
12123
12124 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12125 ) -> impl ::core::future::Future<Output = ()>;
12126}
12127
12128impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageAdmin
12129where
12130 ___H: StorageAdminLocalServerHandler<___T>,
12131 ___T: ::fidl_next::Transport,
12132 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12133 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12134 Constraint = (),
12135 >,
12136 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12137 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12138 Constraint = (),
12139 >,
12140 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12141 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12142 Constraint = (),
12143 >,
12144 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12145 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12146 Constraint = (),
12147 >,
12148{
12149 async fn on_one_way(
12150 handler: &mut ___H,
12151 ordinal: u64,
12152 flexibility: ::fidl_next::protocol::Flexibility,
12153 body: ::fidl_next::Body<___T>,
12154 ) -> ::core::result::Result<
12155 (),
12156 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12157 > {
12158 match ordinal {
12159 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12160 }
12161 }
12162
12163 async fn on_two_way(
12164 handler: &mut ___H,
12165 ordinal: u64,
12166 flexibility: ::fidl_next::protocol::Flexibility,
12167 body: ::fidl_next::Body<___T>,
12168 responder: ::fidl_next::protocol::Responder<___T>,
12169 ) -> ::core::result::Result<
12170 (),
12171 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12172 > {
12173 match ordinal {
12174 7848267339832116087 => {
12175 let responder = ::fidl_next::Responder::from_untyped(responder);
12176
12177 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12178 Ok(decoded) => {
12179 handler
12180 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12181 .await;
12182 Ok(())
12183 }
12184 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12185 ordinal: 7848267339832116087,
12186 error,
12187 }),
12188 }
12189 }
12190
12191 8525152599685368827 => {
12192 let responder = ::fidl_next::Responder::from_untyped(responder);
12193
12194 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12195 Ok(decoded) => {
12196 handler
12197 .list_storage_in_realm(
12198 ::fidl_next::Request::from_decoded(decoded),
12199 responder,
12200 )
12201 .await;
12202 Ok(())
12203 }
12204 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12205 ordinal: 8525152599685368827,
12206 error,
12207 }),
12208 }
12209 }
12210
12211 5188727505160068593 => {
12212 let responder = ::fidl_next::Responder::from_untyped(responder);
12213
12214 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12215 Ok(decoded) => {
12216 handler
12217 .open_component_storage_by_id(
12218 ::fidl_next::Request::from_decoded(decoded),
12219 responder,
12220 )
12221 .await;
12222 Ok(())
12223 }
12224 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12225 ordinal: 5188727505160068593,
12226 error,
12227 }),
12228 }
12229 }
12230
12231 1618975681517712474 => {
12232 let responder = ::fidl_next::Responder::from_untyped(responder);
12233
12234 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12235 Ok(decoded) => {
12236 handler
12237 .delete_component_storage(
12238 ::fidl_next::Request::from_decoded(decoded),
12239 responder,
12240 )
12241 .await;
12242 Ok(())
12243 }
12244 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12245 ordinal: 1618975681517712474,
12246 error,
12247 }),
12248 }
12249 }
12250
12251 8586643915409794760 => {
12252 let responder = ::fidl_next::Responder::from_untyped(responder);
12253
12254 handler.get_status(responder).await;
12255 Ok(())
12256 }
12257
12258 3380374508900862683 => {
12259 let responder = ::fidl_next::Responder::from_untyped(responder);
12260
12261 handler.delete_all_storage_contents(responder).await;
12262 Ok(())
12263 }
12264
12265 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12266 }
12267 }
12268}
12269
12270pub trait StorageAdminClientHandler<
12274 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12275 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12276>
12277{
12278}
12279
12280impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageAdmin
12281where
12282 ___H: StorageAdminClientHandler<___T> + ::core::marker::Send,
12283 ___T: ::fidl_next::Transport,
12284{
12285 async fn on_event(
12286 handler: &mut ___H,
12287 ordinal: u64,
12288 flexibility: ::fidl_next::protocol::Flexibility,
12289 body: ::fidl_next::Body<___T>,
12290 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12291 match ordinal {
12292 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12293 }
12294 }
12295}
12296
12297pub trait StorageAdminServerHandler<
12301 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12302 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12303>
12304{
12305 #[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"]
12306 fn open_storage(
12307 &mut self,
12308
12309 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12310
12311 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12312 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12313
12314 #[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"]
12315 fn list_storage_in_realm(
12316 &mut self,
12317
12318 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12319
12320 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12321 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12322
12323 #[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"]
12324 fn open_component_storage_by_id(
12325 &mut self,
12326
12327 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12328
12329 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12330 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12331
12332 #[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"]
12333 fn delete_component_storage(
12334 &mut self,
12335
12336 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12337
12338 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12339 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12340
12341 #[doc = " Get the current status of the storage.\n"]
12342 fn get_status(
12343 &mut self,
12344
12345 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12346 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12347
12348 #[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"]
12349 fn delete_all_storage_contents(
12350 &mut self,
12351
12352 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12353 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12354}
12355
12356impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageAdmin
12357where
12358 ___H: StorageAdminServerHandler<___T> + ::core::marker::Send,
12359 ___T: ::fidl_next::Transport,
12360 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12361 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12362 Constraint = (),
12363 >,
12364 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12365 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12366 Constraint = (),
12367 >,
12368 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12369 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12370 Constraint = (),
12371 >,
12372 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12373 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12374 Constraint = (),
12375 >,
12376{
12377 async fn on_one_way(
12378 handler: &mut ___H,
12379 ordinal: u64,
12380 flexibility: ::fidl_next::protocol::Flexibility,
12381 body: ::fidl_next::Body<___T>,
12382 ) -> ::core::result::Result<
12383 (),
12384 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12385 > {
12386 match ordinal {
12387 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12388 }
12389 }
12390
12391 async fn on_two_way(
12392 handler: &mut ___H,
12393 ordinal: u64,
12394 flexibility: ::fidl_next::protocol::Flexibility,
12395 body: ::fidl_next::Body<___T>,
12396 responder: ::fidl_next::protocol::Responder<___T>,
12397 ) -> ::core::result::Result<
12398 (),
12399 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12400 > {
12401 match ordinal {
12402 7848267339832116087 => {
12403 let responder = ::fidl_next::Responder::from_untyped(responder);
12404
12405 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12406 Ok(decoded) => {
12407 handler
12408 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12409 .await;
12410 Ok(())
12411 }
12412 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12413 ordinal: 7848267339832116087,
12414 error,
12415 }),
12416 }
12417 }
12418
12419 8525152599685368827 => {
12420 let responder = ::fidl_next::Responder::from_untyped(responder);
12421
12422 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12423 Ok(decoded) => {
12424 handler
12425 .list_storage_in_realm(
12426 ::fidl_next::Request::from_decoded(decoded),
12427 responder,
12428 )
12429 .await;
12430 Ok(())
12431 }
12432 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12433 ordinal: 8525152599685368827,
12434 error,
12435 }),
12436 }
12437 }
12438
12439 5188727505160068593 => {
12440 let responder = ::fidl_next::Responder::from_untyped(responder);
12441
12442 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12443 Ok(decoded) => {
12444 handler
12445 .open_component_storage_by_id(
12446 ::fidl_next::Request::from_decoded(decoded),
12447 responder,
12448 )
12449 .await;
12450 Ok(())
12451 }
12452 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12453 ordinal: 5188727505160068593,
12454 error,
12455 }),
12456 }
12457 }
12458
12459 1618975681517712474 => {
12460 let responder = ::fidl_next::Responder::from_untyped(responder);
12461
12462 match ::fidl_next::AsDecoderExt::into_decoded(body) {
12463 Ok(decoded) => {
12464 handler
12465 .delete_component_storage(
12466 ::fidl_next::Request::from_decoded(decoded),
12467 responder,
12468 )
12469 .await;
12470 Ok(())
12471 }
12472 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12473 ordinal: 1618975681517712474,
12474 error,
12475 }),
12476 }
12477 }
12478
12479 8586643915409794760 => {
12480 let responder = ::fidl_next::Responder::from_untyped(responder);
12481
12482 handler.get_status(responder).await;
12483 Ok(())
12484 }
12485
12486 3380374508900862683 => {
12487 let responder = ::fidl_next::Responder::from_untyped(responder);
12488
12489 handler.delete_all_storage_contents(responder).await;
12490 Ok(())
12491 }
12492
12493 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12494 }
12495 }
12496}
12497
12498impl<___T> StorageAdminClientHandler<___T> for ::fidl_next::IgnoreEvents where
12499 ___T: ::fidl_next::Transport
12500{
12501}
12502
12503impl<___H, ___T> StorageAdminLocalClientHandler<___T> for ::fidl_next::Local<___H>
12504where
12505 ___H: StorageAdminClientHandler<___T>,
12506 ___T: ::fidl_next::Transport,
12507{
12508}
12509
12510impl<___H, ___T> StorageAdminLocalServerHandler<___T> for ::fidl_next::Local<___H>
12511where
12512 ___H: StorageAdminServerHandler<___T>,
12513 ___T: ::fidl_next::Transport,
12514{
12515 async fn open_storage(
12516 &mut self,
12517
12518 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12519
12520 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12521 ) {
12522 ___H::open_storage(&mut self.0, request, responder).await
12523 }
12524
12525 async fn list_storage_in_realm(
12526 &mut self,
12527
12528 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12529
12530 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12531 ) {
12532 ___H::list_storage_in_realm(&mut self.0, request, responder).await
12533 }
12534
12535 async fn open_component_storage_by_id(
12536 &mut self,
12537
12538 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12539
12540 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12541 ) {
12542 ___H::open_component_storage_by_id(&mut self.0, request, responder).await
12543 }
12544
12545 async fn delete_component_storage(
12546 &mut self,
12547
12548 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12549
12550 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12551 ) {
12552 ___H::delete_component_storage(&mut self.0, request, responder).await
12553 }
12554
12555 async fn get_status(
12556 &mut self,
12557
12558 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12559 ) {
12560 ___H::get_status(&mut self.0, responder).await
12561 }
12562
12563 async fn delete_all_storage_contents(
12564 &mut self,
12565
12566 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12567 ) {
12568 ___H::delete_all_storage_contents(&mut self.0, responder).await
12569 }
12570}
12571
12572pub use fidl_next_common_fuchsia_component::*;