1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_component::natural::*;
8
9 #[doc = " Payload for CapabilityRequested events\n"]
10 #[derive(Debug, Default, PartialEq)]
11 pub struct CapabilityRequestedPayload {
12 pub name: ::core::option::Option<::std::string::String>,
13
14 pub capability: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
15 }
16
17 impl CapabilityRequestedPayload {
18 fn __max_ordinal(&self) -> usize {
19 if self.capability.is_some() {
20 return 2;
21 }
22
23 if self.name.is_some() {
24 return 1;
25 }
26
27 0
28 }
29 }
30
31 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityRequestedPayload<'static>, ___E>
32 for CapabilityRequestedPayload
33 where
34 ___E: ::fidl_next::Encoder + ?Sized,
35 ___E: ::fidl_next::fuchsia::HandleEncoder,
36 {
37 #[inline]
38 fn encode(
39 mut self,
40 encoder: &mut ___E,
41 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRequestedPayload<'static>>,
42 _: (),
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::munge!(let crate::wire::CapabilityRequestedPayload { table } = out);
45
46 let max_ord = self.__max_ordinal();
47
48 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
49 ::fidl_next::Wire::zero_padding(&mut out);
50
51 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
52 ::fidl_next::wire::Envelope,
53 >(encoder, max_ord);
54
55 for i in 1..=max_ord {
56 match i {
57 2 => {
58 if let Some(value) = self.capability.take() {
59 ::fidl_next::wire::Envelope::encode_value::<
60 ::fidl_next::wire::fuchsia::Channel,
61 ___E,
62 >(
63 value, preallocated.encoder, &mut out, ()
64 )?;
65 } else {
66 ::fidl_next::wire::Envelope::encode_zero(&mut out)
67 }
68 }
69
70 1 => {
71 if let Some(value) = self.name.take() {
72 ::fidl_next::wire::Envelope::encode_value::<
73 ::fidl_next::wire::String<'static>,
74 ___E,
75 >(
76 value, preallocated.encoder, &mut out, 255
77 )?;
78 } else {
79 ::fidl_next::wire::Envelope::encode_zero(&mut out)
80 }
81 }
82
83 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
84 }
85 unsafe {
86 preallocated.write_next(out.assume_init_ref());
87 }
88 }
89
90 ::fidl_next::wire::Table::encode_len(table, max_ord);
91
92 Ok(())
93 }
94 }
95
96 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityRequestedPayload<'de>>
97 for CapabilityRequestedPayload
98 {
99 #[inline]
100 fn from_wire(wire_: crate::wire::CapabilityRequestedPayload<'de>) -> Self {
101 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
102
103 let name = wire_.table.get(1);
104
105 let capability = wire_.table.get(2);
106
107 Self {
108 name: name.map(|envelope| {
109 ::fidl_next::FromWire::from_wire(unsafe {
110 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
111 })
112 }),
113
114 capability: capability.map(|envelope| {
115 ::fidl_next::FromWire::from_wire(unsafe {
116 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
117 })
118 }),
119 }
120 }
121 }
122
123 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
124 #[repr(C)]
125 pub struct ControllerIsStartedResponse {
126 pub is_started: bool,
127 }
128
129 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
130 for ControllerIsStartedResponse
131 where
132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
133 ___E: ::fidl_next::fuchsia::HandleEncoder,
134 {
135 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
136 Self,
137 crate::wire::ControllerIsStartedResponse,
138 > = unsafe {
139 ::fidl_next::CopyOptimization::enable_if(
140 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
141 )
142 };
143
144 #[inline]
145 fn encode(
146 self,
147 encoder_: &mut ___E,
148 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
149 _: (),
150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
151 ::fidl_next::munge! {
152 let crate::wire::ControllerIsStartedResponse {
153 is_started,
154
155 } = out_;
156 }
157
158 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
159
160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_started.as_mut_ptr()) };
161
162 Ok(())
163 }
164 }
165
166 unsafe impl<___E>
167 ::fidl_next::EncodeOption<
168 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
169 ___E,
170 > for ControllerIsStartedResponse
171 where
172 ___E: ::fidl_next::Encoder + ?Sized,
173 ControllerIsStartedResponse:
174 ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>,
175 {
176 #[inline]
177 fn encode_option(
178 this: ::core::option::Option<Self>,
179 encoder: &mut ___E,
180 out: &mut ::core::mem::MaybeUninit<
181 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
182 >,
183 _: (),
184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185 if let Some(inner) = this {
186 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
187 ::fidl_next::wire::Box::encode_present(out);
188 } else {
189 ::fidl_next::wire::Box::encode_absent(out);
190 }
191
192 Ok(())
193 }
194 }
195
196 impl ::fidl_next::FromWire<crate::wire::ControllerIsStartedResponse>
197 for ControllerIsStartedResponse
198 {
199 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
200 crate::wire::ControllerIsStartedResponse,
201 Self,
202 > = unsafe {
203 ::fidl_next::CopyOptimization::enable_if(
204 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
205 )
206 };
207
208 #[inline]
209 fn from_wire(wire: crate::wire::ControllerIsStartedResponse) -> Self {
210 Self { is_started: ::fidl_next::FromWire::from_wire(wire.is_started) }
211 }
212 }
213
214 #[derive(Debug, PartialEq)]
215 #[repr(C)]
216 pub struct ControllerGetExposedDictionaryResponse {
217 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
218 }
219
220 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
221 for ControllerGetExposedDictionaryResponse
222 where
223 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
224 ___E: ::fidl_next::fuchsia::HandleEncoder,
225 {
226 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
227 Self,
228 crate::wire::ControllerGetExposedDictionaryResponse,
229 > = unsafe {
230 ::fidl_next::CopyOptimization::enable_if(
231 true
232
233 && <
234 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
235 >::COPY_OPTIMIZATION.is_enabled()
236
237 )
238 };
239
240 #[inline]
241 fn encode(
242 self,
243 encoder_: &mut ___E,
244 out_: &mut ::core::mem::MaybeUninit<
245 crate::wire::ControllerGetExposedDictionaryResponse,
246 >,
247 _: (),
248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
249 ::fidl_next::munge! {
250 let crate::wire::ControllerGetExposedDictionaryResponse {
251 dictionary,
252
253 } = out_;
254 }
255
256 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
257
258 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
259
260 Ok(())
261 }
262 }
263
264 unsafe impl<___E>
265 ::fidl_next::EncodeOption<
266 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetExposedDictionaryResponse>,
267 ___E,
268 > for ControllerGetExposedDictionaryResponse
269 where
270 ___E: ::fidl_next::Encoder + ?Sized,
271 ControllerGetExposedDictionaryResponse:
272 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>,
273 {
274 #[inline]
275 fn encode_option(
276 this: ::core::option::Option<Self>,
277 encoder: &mut ___E,
278 out: &mut ::core::mem::MaybeUninit<
279 ::fidl_next::wire::Box<
280 'static,
281 crate::wire::ControllerGetExposedDictionaryResponse,
282 >,
283 >,
284 _: (),
285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
286 if let Some(inner) = this {
287 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
288 ::fidl_next::wire::Box::encode_present(out);
289 } else {
290 ::fidl_next::wire::Box::encode_absent(out);
291 }
292
293 Ok(())
294 }
295 }
296
297 impl ::fidl_next::FromWire<crate::wire::ControllerGetExposedDictionaryResponse>
298 for ControllerGetExposedDictionaryResponse
299 {
300 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
301 crate::wire::ControllerGetExposedDictionaryResponse,
302 Self,
303 > = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true
306
307 && <
308 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
309 >::COPY_OPTIMIZATION.is_enabled()
310
311 )
312 };
313
314 #[inline]
315 fn from_wire(wire: crate::wire::ControllerGetExposedDictionaryResponse) -> Self {
316 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
317 }
318 }
319
320 #[derive(Debug, PartialEq)]
321 #[repr(C)]
322 pub struct ControllerGetOutputDictionaryResponse {
323 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
324 }
325
326 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
327 for ControllerGetOutputDictionaryResponse
328 where
329 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
330 ___E: ::fidl_next::fuchsia::HandleEncoder,
331 {
332 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
333 Self,
334 crate::wire::ControllerGetOutputDictionaryResponse,
335 > = unsafe {
336 ::fidl_next::CopyOptimization::enable_if(
337 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
338 ::fidl_next::wire::fuchsia::EventPair,
339 ___E,
340 >>::COPY_OPTIMIZATION
341 .is_enabled(),
342 )
343 };
344
345 #[inline]
346 fn encode(
347 self,
348 encoder_: &mut ___E,
349 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
350 _: (),
351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
352 ::fidl_next::munge! {
353 let crate::wire::ControllerGetOutputDictionaryResponse {
354 dictionary,
355
356 } = out_;
357 }
358
359 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
360
361 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
362
363 Ok(())
364 }
365 }
366
367 unsafe impl<___E>
368 ::fidl_next::EncodeOption<
369 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
370 ___E,
371 > for ControllerGetOutputDictionaryResponse
372 where
373 ___E: ::fidl_next::Encoder + ?Sized,
374 ControllerGetOutputDictionaryResponse:
375 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>,
376 {
377 #[inline]
378 fn encode_option(
379 this: ::core::option::Option<Self>,
380 encoder: &mut ___E,
381 out: &mut ::core::mem::MaybeUninit<
382 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
383 >,
384 _: (),
385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
386 if let Some(inner) = this {
387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
388 ::fidl_next::wire::Box::encode_present(out);
389 } else {
390 ::fidl_next::wire::Box::encode_absent(out);
391 }
392
393 Ok(())
394 }
395 }
396
397 impl ::fidl_next::FromWire<crate::wire::ControllerGetOutputDictionaryResponse>
398 for ControllerGetOutputDictionaryResponse
399 {
400 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
401 crate::wire::ControllerGetOutputDictionaryResponse,
402 Self,
403 > = unsafe {
404 ::fidl_next::CopyOptimization::enable_if(
405 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
406 ::fidl_next::wire::fuchsia::EventPair,
407 >>::COPY_OPTIMIZATION
408 .is_enabled(),
409 )
410 };
411
412 #[inline]
413 fn from_wire(wire: crate::wire::ControllerGetOutputDictionaryResponse) -> Self {
414 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
415 }
416 }
417
418 #[doc = " A single component namespace entry, which describes a namespace mount point\n (`path`) and the directory backing it (`directory`). This type is usually\n composed inside a vector. See `ComponentStartInfo.ns` for more details.\n"]
419 #[derive(Debug, Default, PartialEq)]
420 pub struct NamespaceEntry {
421 pub path: ::core::option::Option<::std::string::String>,
422
423 pub directory: ::core::option::Option<
424 ::fidl_next::ClientEnd<
425 ::fidl_next_fuchsia_io::Directory,
426 ::fidl_next::fuchsia::zx::Channel,
427 >,
428 >,
429 }
430
431 impl NamespaceEntry {
432 fn __max_ordinal(&self) -> usize {
433 if self.directory.is_some() {
434 return 2;
435 }
436
437 if self.path.is_some() {
438 return 1;
439 }
440
441 0
442 }
443 }
444
445 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceEntry<'static>, ___E> for NamespaceEntry
446 where
447 ___E: ::fidl_next::Encoder + ?Sized,
448 ___E: ::fidl_next::fuchsia::HandleEncoder,
449 {
450 #[inline]
451 fn encode(
452 mut self,
453 encoder: &mut ___E,
454 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceEntry<'static>>,
455 _: (),
456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
457 ::fidl_next::munge!(let crate::wire::NamespaceEntry { table } = out);
458
459 let max_ord = self.__max_ordinal();
460
461 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
462 ::fidl_next::Wire::zero_padding(&mut out);
463
464 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
465 ::fidl_next::wire::Envelope,
466 >(encoder, max_ord);
467
468 for i in 1..=max_ord {
469 match i {
470 2 => {
471 if let Some(value) = self.directory.take() {
472 ::fidl_next::wire::Envelope::encode_value::<
473 ::fidl_next::ClientEnd<
474 ::fidl_next_fuchsia_io::Directory,
475 ::fidl_next::wire::fuchsia::Channel,
476 >,
477 ___E,
478 >(
479 value, preallocated.encoder, &mut out, ()
480 )?;
481 } else {
482 ::fidl_next::wire::Envelope::encode_zero(&mut out)
483 }
484 }
485
486 1 => {
487 if let Some(value) = self.path.take() {
488 ::fidl_next::wire::Envelope::encode_value::<
489 ::fidl_next::wire::String<'static>,
490 ___E,
491 >(
492 value, preallocated.encoder, &mut out, 4095
493 )?;
494 } else {
495 ::fidl_next::wire::Envelope::encode_zero(&mut out)
496 }
497 }
498
499 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
500 }
501 unsafe {
502 preallocated.write_next(out.assume_init_ref());
503 }
504 }
505
506 ::fidl_next::wire::Table::encode_len(table, max_ord);
507
508 Ok(())
509 }
510 }
511
512 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceEntry<'de>> for NamespaceEntry {
513 #[inline]
514 fn from_wire(wire_: crate::wire::NamespaceEntry<'de>) -> Self {
515 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
516
517 let path = wire_.table.get(1);
518
519 let directory = wire_.table.get(2);
520
521 Self {
522 path: path.map(|envelope| {
523 ::fidl_next::FromWire::from_wire(unsafe {
524 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
525 })
526 }),
527
528 directory: directory.map(|envelope| {
529 ::fidl_next::FromWire::from_wire(unsafe {
530 envelope.read_unchecked::<::fidl_next::ClientEnd<
531 ::fidl_next_fuchsia_io::Directory,
532 ::fidl_next::wire::fuchsia::Channel,
533 >>()
534 })
535 }),
536 }
537 }
538 }
539
540 #[derive(Debug, Default, PartialEq)]
541 pub struct StartChildArgs {
542 pub numbered_handles: ::core::option::Option<
543 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
544 >,
545
546 pub namespace_entries:
547 ::core::option::Option<::std::vec::Vec<crate::natural::NamespaceEntry>>,
548
549 pub dictionary:
550 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
551
552 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
553 }
554
555 impl StartChildArgs {
556 fn __max_ordinal(&self) -> usize {
557 if self.additional_inputs.is_some() {
558 return 4;
559 }
560
561 if self.dictionary.is_some() {
562 return 3;
563 }
564
565 if self.namespace_entries.is_some() {
566 return 2;
567 }
568
569 if self.numbered_handles.is_some() {
570 return 1;
571 }
572
573 0
574 }
575 }
576
577 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E> for StartChildArgs
578 where
579 ___E: ::fidl_next::Encoder + ?Sized,
580 ___E: ::fidl_next::fuchsia::HandleEncoder,
581 {
582 #[inline]
583 fn encode(
584 mut self,
585 encoder: &mut ___E,
586 out: &mut ::core::mem::MaybeUninit<crate::wire::StartChildArgs<'static>>,
587 _: (),
588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
589 ::fidl_next::munge!(let crate::wire::StartChildArgs { table } = out);
590
591 let max_ord = self.__max_ordinal();
592
593 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
594 ::fidl_next::Wire::zero_padding(&mut out);
595
596 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
597 ::fidl_next::wire::Envelope,
598 >(encoder, max_ord);
599
600 for i in 1..=max_ord {
601 match i {
602 4 => {
603 if let Some(value) = self.additional_inputs.take() {
604 ::fidl_next::wire::Envelope::encode_value::<
605 ::fidl_next::wire::fuchsia::EventPair,
606 ___E,
607 >(
608 value, preallocated.encoder, &mut out, ()
609 )?;
610 } else {
611 ::fidl_next::wire::Envelope::encode_zero(&mut out)
612 }
613 }
614
615 3 => {
616 if let Some(value) = self.dictionary.take() {
617 ::fidl_next::wire::Envelope::encode_value::<
618 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
619 ___E,
620 >(
621 value, preallocated.encoder, &mut out, ()
622 )?;
623 } else {
624 ::fidl_next::wire::Envelope::encode_zero(&mut out)
625 }
626 }
627
628 2 => {
629 if let Some(value) = self.namespace_entries.take() {
630 ::fidl_next::wire::Envelope::encode_value::<
631 ::fidl_next::wire::Vector<
632 'static,
633 crate::wire::NamespaceEntry<'static>,
634 >,
635 ___E,
636 >(
637 value, preallocated.encoder, &mut out, (32, ())
638 )?;
639 } else {
640 ::fidl_next::wire::Envelope::encode_zero(&mut out)
641 }
642 }
643
644 1 => {
645 if let Some(value) = self.numbered_handles.take() {
646 ::fidl_next::wire::Envelope::encode_value::<
647 ::fidl_next::wire::Vector<
648 'static,
649 ::fidl_next_fuchsia_process::wire::HandleInfo,
650 >,
651 ___E,
652 >(
653 value, preallocated.encoder, &mut out, (128, ())
654 )?;
655 } else {
656 ::fidl_next::wire::Envelope::encode_zero(&mut out)
657 }
658 }
659
660 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
661 }
662 unsafe {
663 preallocated.write_next(out.assume_init_ref());
664 }
665 }
666
667 ::fidl_next::wire::Table::encode_len(table, max_ord);
668
669 Ok(())
670 }
671 }
672
673 impl<'de> ::fidl_next::FromWire<crate::wire::StartChildArgs<'de>> for StartChildArgs {
674 #[inline]
675 fn from_wire(wire_: crate::wire::StartChildArgs<'de>) -> Self {
676 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
677
678 let numbered_handles = wire_.table.get(1);
679
680 let namespace_entries = wire_.table.get(2);
681
682 let dictionary = wire_.table.get(3);
683
684 let additional_inputs = wire_.table.get(4);
685
686 Self {
687
688
689 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
690 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
691 )),
692
693
694 namespace_entries: namespace_entries.map(|envelope| ::fidl_next::FromWire::from_wire(
695 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>() }
696 )),
697
698
699 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
700 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
701 )),
702
703
704 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
705 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
706 )),
707
708 }
709 }
710 }
711
712 #[derive(Debug, PartialEq)]
713 pub struct ControllerStartRequest {
714 pub args: crate::natural::StartChildArgs,
715
716 pub execution_controller:
717 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::fuchsia::zx::Channel>,
718 }
719
720 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
721 for ControllerStartRequest
722 where
723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
724 ___E: ::fidl_next::Encoder,
725 ___E: ::fidl_next::fuchsia::HandleEncoder,
726 {
727 #[inline]
728 fn encode(
729 self,
730 encoder_: &mut ___E,
731 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
732 _: (),
733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
734 ::fidl_next::munge! {
735 let crate::wire::ControllerStartRequest {
736 args,
737 execution_controller,
738
739 } = out_;
740 }
741
742 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
743
744 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
745
746 ::fidl_next::Encode::encode(
747 self.execution_controller,
748 encoder_,
749 execution_controller,
750 (),
751 )?;
752
753 let mut _field =
754 unsafe { ::fidl_next::Slot::new_unchecked(execution_controller.as_mut_ptr()) };
755
756 Ok(())
757 }
758 }
759
760 unsafe impl<___E>
761 ::fidl_next::EncodeOption<
762 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
763 ___E,
764 > for ControllerStartRequest
765 where
766 ___E: ::fidl_next::Encoder + ?Sized,
767 ControllerStartRequest:
768 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>,
769 {
770 #[inline]
771 fn encode_option(
772 this: ::core::option::Option<Self>,
773 encoder: &mut ___E,
774 out: &mut ::core::mem::MaybeUninit<
775 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
776 >,
777 _: (),
778 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
779 if let Some(inner) = this {
780 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
781 ::fidl_next::wire::Box::encode_present(out);
782 } else {
783 ::fidl_next::wire::Box::encode_absent(out);
784 }
785
786 Ok(())
787 }
788 }
789
790 impl<'de> ::fidl_next::FromWire<crate::wire::ControllerStartRequest<'de>>
791 for ControllerStartRequest
792 {
793 #[inline]
794 fn from_wire(wire: crate::wire::ControllerStartRequest<'de>) -> Self {
795 Self {
796 args: ::fidl_next::FromWire::from_wire(wire.args),
797
798 execution_controller: ::fidl_next::FromWire::from_wire(wire.execution_controller),
799 }
800 }
801 }
802
803 #[derive(Debug, PartialEq)]
804 #[repr(C)]
805 pub struct ControllerOpenExposedDirRequest {
806 pub exposed_dir: ::fidl_next::ServerEnd<
807 ::fidl_next_fuchsia_io::Directory,
808 ::fidl_next::fuchsia::zx::Channel,
809 >,
810 }
811
812 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
813 for ControllerOpenExposedDirRequest
814 where
815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
816 ___E: ::fidl_next::fuchsia::HandleEncoder,
817 {
818 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
819 Self,
820 crate::wire::ControllerOpenExposedDirRequest,
821 > = unsafe {
822 ::fidl_next::CopyOptimization::enable_if(
823 true && <::fidl_next::ServerEnd<
824 ::fidl_next_fuchsia_io::Directory,
825 ::fidl_next::fuchsia::zx::Channel,
826 > as ::fidl_next::Encode<
827 ::fidl_next::ServerEnd<
828 ::fidl_next_fuchsia_io::Directory,
829 ::fidl_next::wire::fuchsia::Channel,
830 >,
831 ___E,
832 >>::COPY_OPTIMIZATION
833 .is_enabled(),
834 )
835 };
836
837 #[inline]
838 fn encode(
839 self,
840 encoder_: &mut ___E,
841 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
842 _: (),
843 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
844 ::fidl_next::munge! {
845 let crate::wire::ControllerOpenExposedDirRequest {
846 exposed_dir,
847
848 } = out_;
849 }
850
851 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
852
853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
854
855 Ok(())
856 }
857 }
858
859 unsafe impl<___E>
860 ::fidl_next::EncodeOption<
861 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
862 ___E,
863 > for ControllerOpenExposedDirRequest
864 where
865 ___E: ::fidl_next::Encoder + ?Sized,
866 ControllerOpenExposedDirRequest:
867 ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>,
868 {
869 #[inline]
870 fn encode_option(
871 this: ::core::option::Option<Self>,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<
874 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
875 >,
876 _: (),
877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
878 if let Some(inner) = this {
879 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
880 ::fidl_next::wire::Box::encode_present(out);
881 } else {
882 ::fidl_next::wire::Box::encode_absent(out);
883 }
884
885 Ok(())
886 }
887 }
888
889 impl ::fidl_next::FromWire<crate::wire::ControllerOpenExposedDirRequest>
890 for ControllerOpenExposedDirRequest
891 {
892 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
893 crate::wire::ControllerOpenExposedDirRequest,
894 Self,
895 > = unsafe {
896 ::fidl_next::CopyOptimization::enable_if(
897 true && <::fidl_next::ServerEnd<
898 ::fidl_next_fuchsia_io::Directory,
899 ::fidl_next::fuchsia::zx::Channel,
900 > as ::fidl_next::FromWire<
901 ::fidl_next::ServerEnd<
902 ::fidl_next_fuchsia_io::Directory,
903 ::fidl_next::wire::fuchsia::Channel,
904 >,
905 >>::COPY_OPTIMIZATION
906 .is_enabled(),
907 )
908 };
909
910 #[inline]
911 fn from_wire(wire: crate::wire::ControllerOpenExposedDirRequest) -> Self {
912 Self { exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir) }
913 }
914 }
915
916 #[derive(Debug, Default, PartialEq)]
917 pub struct CreateChildArgs {
918 pub numbered_handles: ::core::option::Option<
919 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
920 >,
921
922 pub dynamic_offers: ::core::option::Option<
923 ::std::vec::Vec<::fidl_next_fuchsia_component_decl::natural::Offer>,
924 >,
925
926 pub controller: ::core::option::Option<
927 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
928 >,
929
930 pub dictionary:
931 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
932
933 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
934 }
935
936 impl CreateChildArgs {
937 fn __max_ordinal(&self) -> usize {
938 if self.additional_inputs.is_some() {
939 return 5;
940 }
941
942 if self.dictionary.is_some() {
943 return 4;
944 }
945
946 if self.controller.is_some() {
947 return 3;
948 }
949
950 if self.dynamic_offers.is_some() {
951 return 2;
952 }
953
954 if self.numbered_handles.is_some() {
955 return 1;
956 }
957
958 0
959 }
960 }
961
962 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>
963 for CreateChildArgs
964 where
965 ___E: ::fidl_next::Encoder + ?Sized,
966 ___E: ::fidl_next::fuchsia::HandleEncoder,
967 {
968 #[inline]
969 fn encode(
970 mut self,
971 encoder: &mut ___E,
972 out: &mut ::core::mem::MaybeUninit<crate::wire::CreateChildArgs<'static>>,
973 _: (),
974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
975 ::fidl_next::munge!(let crate::wire::CreateChildArgs { table } = out);
976
977 let max_ord = self.__max_ordinal();
978
979 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
980 ::fidl_next::Wire::zero_padding(&mut out);
981
982 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
983 ::fidl_next::wire::Envelope,
984 >(encoder, max_ord);
985
986 for i in 1..=max_ord {
987 match i {
988 5 => {
989 if let Some(value) = self.additional_inputs.take() {
990 ::fidl_next::wire::Envelope::encode_value::<
991 ::fidl_next::wire::fuchsia::EventPair,
992 ___E,
993 >(
994 value, preallocated.encoder, &mut out, ()
995 )?;
996 } else {
997 ::fidl_next::wire::Envelope::encode_zero(&mut out)
998 }
999 }
1000
1001 4 => {
1002 if let Some(value) = self.dictionary.take() {
1003 ::fidl_next::wire::Envelope::encode_value::<
1004 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
1005 ___E,
1006 >(
1007 value, preallocated.encoder, &mut out, ()
1008 )?;
1009 } else {
1010 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1011 }
1012 }
1013
1014 3 => {
1015 if let Some(value) = self.controller.take() {
1016 ::fidl_next::wire::Envelope::encode_value::<
1017 ::fidl_next::ServerEnd<
1018 crate::Controller,
1019 ::fidl_next::wire::fuchsia::Channel,
1020 >,
1021 ___E,
1022 >(
1023 value, preallocated.encoder, &mut out, ()
1024 )?;
1025 } else {
1026 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1027 }
1028 }
1029
1030 2 => {
1031 if let Some(value) = self.dynamic_offers.take() {
1032 ::fidl_next::wire::Envelope::encode_value::<
1033 ::fidl_next::wire::Vector<
1034 'static,
1035 ::fidl_next_fuchsia_component_decl::wire::Offer<'static>,
1036 >,
1037 ___E,
1038 >(
1039 value, preallocated.encoder, &mut out, (128, ())
1040 )?;
1041 } else {
1042 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1043 }
1044 }
1045
1046 1 => {
1047 if let Some(value) = self.numbered_handles.take() {
1048 ::fidl_next::wire::Envelope::encode_value::<
1049 ::fidl_next::wire::Vector<
1050 'static,
1051 ::fidl_next_fuchsia_process::wire::HandleInfo,
1052 >,
1053 ___E,
1054 >(
1055 value, preallocated.encoder, &mut out, (128, ())
1056 )?;
1057 } else {
1058 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1059 }
1060 }
1061
1062 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1063 }
1064 unsafe {
1065 preallocated.write_next(out.assume_init_ref());
1066 }
1067 }
1068
1069 ::fidl_next::wire::Table::encode_len(table, max_ord);
1070
1071 Ok(())
1072 }
1073 }
1074
1075 impl<'de> ::fidl_next::FromWire<crate::wire::CreateChildArgs<'de>> for CreateChildArgs {
1076 #[inline]
1077 fn from_wire(wire_: crate::wire::CreateChildArgs<'de>) -> Self {
1078 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1079
1080 let numbered_handles = wire_.table.get(1);
1081
1082 let dynamic_offers = wire_.table.get(2);
1083
1084 let controller = wire_.table.get(3);
1085
1086 let dictionary = wire_.table.get(4);
1087
1088 let additional_inputs = wire_.table.get(5);
1089
1090 Self {
1091
1092
1093 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
1094 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
1095 )),
1096
1097
1098 dynamic_offers: dynamic_offers.map(|envelope| ::fidl_next::FromWire::from_wire(
1099 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>>() }
1100 )),
1101
1102
1103 controller: controller.map(|envelope| ::fidl_next::FromWire::from_wire(
1104 unsafe { envelope.read_unchecked::<::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>>() }
1105 )),
1106
1107
1108 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
1109 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
1110 )),
1111
1112
1113 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
1114 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
1115 )),
1116
1117 }
1118 }
1119 }
1120
1121 #[doc = " Payload for DebugStarted events.\n"]
1122 #[derive(Debug, Default, PartialEq)]
1123 pub struct DebugStartedPayload {
1124 pub runtime_dir: ::core::option::Option<
1125 ::fidl_next::ClientEnd<
1126 ::fidl_next_fuchsia_io::Directory,
1127 ::fidl_next::fuchsia::zx::Channel,
1128 >,
1129 >,
1130
1131 pub break_on_start: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
1132 }
1133
1134 impl DebugStartedPayload {
1135 fn __max_ordinal(&self) -> usize {
1136 if self.break_on_start.is_some() {
1137 return 2;
1138 }
1139
1140 if self.runtime_dir.is_some() {
1141 return 1;
1142 }
1143
1144 0
1145 }
1146 }
1147
1148 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugStartedPayload<'static>, ___E>
1149 for DebugStartedPayload
1150 where
1151 ___E: ::fidl_next::Encoder + ?Sized,
1152 ___E: ::fidl_next::fuchsia::HandleEncoder,
1153 {
1154 #[inline]
1155 fn encode(
1156 mut self,
1157 encoder: &mut ___E,
1158 out: &mut ::core::mem::MaybeUninit<crate::wire::DebugStartedPayload<'static>>,
1159 _: (),
1160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1161 ::fidl_next::munge!(let crate::wire::DebugStartedPayload { table } = out);
1162
1163 let max_ord = self.__max_ordinal();
1164
1165 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1166 ::fidl_next::Wire::zero_padding(&mut out);
1167
1168 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1169 ::fidl_next::wire::Envelope,
1170 >(encoder, max_ord);
1171
1172 for i in 1..=max_ord {
1173 match i {
1174 2 => {
1175 if let Some(value) = self.break_on_start.take() {
1176 ::fidl_next::wire::Envelope::encode_value::<
1177 ::fidl_next::wire::fuchsia::EventPair,
1178 ___E,
1179 >(
1180 value, preallocated.encoder, &mut out, ()
1181 )?;
1182 } else {
1183 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1184 }
1185 }
1186
1187 1 => {
1188 if let Some(value) = self.runtime_dir.take() {
1189 ::fidl_next::wire::Envelope::encode_value::<
1190 ::fidl_next::ClientEnd<
1191 ::fidl_next_fuchsia_io::Directory,
1192 ::fidl_next::wire::fuchsia::Channel,
1193 >,
1194 ___E,
1195 >(
1196 value, preallocated.encoder, &mut out, ()
1197 )?;
1198 } else {
1199 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1200 }
1201 }
1202
1203 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1204 }
1205 unsafe {
1206 preallocated.write_next(out.assume_init_ref());
1207 }
1208 }
1209
1210 ::fidl_next::wire::Table::encode_len(table, max_ord);
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl<'de> ::fidl_next::FromWire<crate::wire::DebugStartedPayload<'de>> for DebugStartedPayload {
1217 #[inline]
1218 fn from_wire(wire_: crate::wire::DebugStartedPayload<'de>) -> Self {
1219 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1220
1221 let runtime_dir = wire_.table.get(1);
1222
1223 let break_on_start = wire_.table.get(2);
1224
1225 Self {
1226 runtime_dir: runtime_dir.map(|envelope| {
1227 ::fidl_next::FromWire::from_wire(unsafe {
1228 envelope.read_unchecked::<::fidl_next::ClientEnd<
1229 ::fidl_next_fuchsia_io::Directory,
1230 ::fidl_next::wire::fuchsia::Channel,
1231 >>()
1232 })
1233 }),
1234
1235 break_on_start: break_on_start.map(|envelope| {
1236 ::fidl_next::FromWire::from_wire(unsafe {
1237 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
1238 })
1239 }),
1240 }
1241 }
1242 }
1243
1244 #[doc = " Encapsulates additional data/protocols for some event types.\n"]
1245 #[derive(Debug, PartialEq)]
1246 pub enum EventPayload {
1247 CapabilityRequested(crate::natural::CapabilityRequestedPayload),
1248
1249 Purged(crate::natural::PurgedPayload),
1250
1251 Discovered(crate::natural::DiscoveredPayload),
1252
1253 Destroyed(crate::natural::DestroyedPayload),
1254
1255 Resolved(crate::natural::ResolvedPayload),
1256
1257 Started(crate::natural::StartedPayload),
1258
1259 Stopped(crate::natural::StoppedPayload),
1260
1261 DebugStarted(crate::natural::DebugStartedPayload),
1262
1263 Unresolved(crate::natural::UnresolvedPayload),
1264
1265 UnknownOrdinal_(u64),
1266 }
1267
1268 impl EventPayload {
1269 pub fn is_unknown(&self) -> bool {
1270 #[allow(unreachable_patterns)]
1271 match self {
1272 Self::UnknownOrdinal_(_) => true,
1273 _ => false,
1274 }
1275 }
1276 }
1277
1278 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E> for EventPayload
1279 where
1280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1281 ___E: ::fidl_next::Encoder,
1282 ___E: ::fidl_next::fuchsia::HandleEncoder,
1283 {
1284 #[inline]
1285 fn encode(
1286 self,
1287 encoder: &mut ___E,
1288 out: &mut ::core::mem::MaybeUninit<crate::wire::EventPayload<'static>>,
1289 _: (),
1290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1291 ::fidl_next::munge!(let crate::wire::EventPayload { raw, _phantom: _ } = out);
1292
1293 match self {
1294 Self::CapabilityRequested(value) => ::fidl_next::wire::Union::encode_as::<
1295 ___E,
1296 crate::wire::CapabilityRequestedPayload<'static>,
1297 >(value, 1, encoder, raw, ())?,
1298
1299 Self::Purged(value) => ::fidl_next::wire::Union::encode_as::<
1300 ___E,
1301 crate::wire::PurgedPayload<'static>,
1302 >(value, 2, encoder, raw, ())?,
1303
1304 Self::Discovered(value) => ::fidl_next::wire::Union::encode_as::<
1305 ___E,
1306 crate::wire::DiscoveredPayload<'static>,
1307 >(value, 4, encoder, raw, ())?,
1308
1309 Self::Destroyed(value) => ::fidl_next::wire::Union::encode_as::<
1310 ___E,
1311 crate::wire::DestroyedPayload<'static>,
1312 >(value, 5, encoder, raw, ())?,
1313
1314 Self::Resolved(value) => ::fidl_next::wire::Union::encode_as::<
1315 ___E,
1316 crate::wire::ResolvedPayload<'static>,
1317 >(value, 6, encoder, raw, ())?,
1318
1319 Self::Started(value) => ::fidl_next::wire::Union::encode_as::<
1320 ___E,
1321 crate::wire::StartedPayload<'static>,
1322 >(value, 7, encoder, raw, ())?,
1323
1324 Self::Stopped(value) => ::fidl_next::wire::Union::encode_as::<
1325 ___E,
1326 crate::wire::StoppedPayload<'static>,
1327 >(value, 8, encoder, raw, ())?,
1328
1329 Self::DebugStarted(value) => ::fidl_next::wire::Union::encode_as::<
1330 ___E,
1331 crate::wire::DebugStartedPayload<'static>,
1332 >(value, 9, encoder, raw, ())?,
1333
1334 Self::Unresolved(value) => ::fidl_next::wire::Union::encode_as::<
1335 ___E,
1336 crate::wire::UnresolvedPayload<'static>,
1337 >(value, 10, encoder, raw, ())?,
1338
1339 Self::UnknownOrdinal_(ordinal) => {
1340 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1341 }
1342 }
1343
1344 Ok(())
1345 }
1346 }
1347
1348 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::EventPayload<'static>, ___E>
1349 for EventPayload
1350 where
1351 ___E: ?Sized,
1352 EventPayload: ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E>,
1353 {
1354 #[inline]
1355 fn encode_option(
1356 this: ::core::option::Option<Self>,
1357 encoder: &mut ___E,
1358 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::EventPayload<'static>>,
1359 _: (),
1360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1361 ::fidl_next::munge!(let crate::wire_optional::EventPayload { raw, _phantom: _ } = &mut *out);
1362
1363 if let Some(inner) = this {
1364 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1365 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1366 } else {
1367 ::fidl_next::wire::Union::encode_absent(raw);
1368 }
1369
1370 Ok(())
1371 }
1372 }
1373
1374 impl<'de> ::fidl_next::FromWire<crate::wire::EventPayload<'de>> for EventPayload {
1375 #[inline]
1376 fn from_wire(wire: crate::wire::EventPayload<'de>) -> Self {
1377 let wire = ::core::mem::ManuallyDrop::new(wire);
1378 match wire.raw.ordinal() {
1379 1 => Self::CapabilityRequested(::fidl_next::FromWire::from_wire(unsafe {
1380 wire.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
1381 })),
1382
1383 2 => Self::Purged(::fidl_next::FromWire::from_wire(unsafe {
1384 wire.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
1385 })),
1386
1387 4 => Self::Discovered(::fidl_next::FromWire::from_wire(unsafe {
1388 wire.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
1389 })),
1390
1391 5 => Self::Destroyed(::fidl_next::FromWire::from_wire(unsafe {
1392 wire.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
1393 })),
1394
1395 6 => Self::Resolved(::fidl_next::FromWire::from_wire(unsafe {
1396 wire.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
1397 })),
1398
1399 7 => Self::Started(::fidl_next::FromWire::from_wire(unsafe {
1400 wire.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
1401 })),
1402
1403 8 => Self::Stopped(::fidl_next::FromWire::from_wire(unsafe {
1404 wire.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
1405 })),
1406
1407 9 => Self::DebugStarted(::fidl_next::FromWire::from_wire(unsafe {
1408 wire.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
1409 })),
1410
1411 10 => Self::Unresolved(::fidl_next::FromWire::from_wire(unsafe {
1412 wire.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
1413 })),
1414
1415 ord => return Self::UnknownOrdinal_(ord as u64),
1416 }
1417 }
1418 }
1419
1420 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>> for EventPayload {
1421 #[inline]
1422 fn from_wire_option(
1423 wire: crate::wire_optional::EventPayload<'de>,
1424 ) -> ::core::option::Option<Self> {
1425 if let Some(inner) = wire.into_option() {
1426 Some(::fidl_next::FromWire::from_wire(inner))
1427 } else {
1428 None
1429 }
1430 }
1431 }
1432
1433 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1434 for Box<EventPayload>
1435 {
1436 #[inline]
1437 fn from_wire_option(
1438 wire: crate::wire_optional::EventPayload<'de>,
1439 ) -> ::core::option::Option<Self> {
1440 <
1441 EventPayload as ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1442 >::from_wire_option(wire).map(Box::new)
1443 }
1444 }
1445
1446 #[doc = " Contains all information about a single event\n"]
1447 #[derive(Debug, Default, PartialEq)]
1448 pub struct Event {
1449 pub header: ::core::option::Option<crate::natural::EventHeader>,
1450
1451 pub payload: ::core::option::Option<crate::natural::EventPayload>,
1452 }
1453
1454 impl Event {
1455 fn __max_ordinal(&self) -> usize {
1456 if self.payload.is_some() {
1457 return 2;
1458 }
1459
1460 if self.header.is_some() {
1461 return 1;
1462 }
1463
1464 0
1465 }
1466 }
1467
1468 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Event<'static>, ___E> for Event
1469 where
1470 ___E: ::fidl_next::Encoder + ?Sized,
1471 ___E: ::fidl_next::fuchsia::HandleEncoder,
1472 {
1473 #[inline]
1474 fn encode(
1475 mut self,
1476 encoder: &mut ___E,
1477 out: &mut ::core::mem::MaybeUninit<crate::wire::Event<'static>>,
1478 _: (),
1479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1480 ::fidl_next::munge!(let crate::wire::Event { table } = out);
1481
1482 let max_ord = self.__max_ordinal();
1483
1484 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1485 ::fidl_next::Wire::zero_padding(&mut out);
1486
1487 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1488 ::fidl_next::wire::Envelope,
1489 >(encoder, max_ord);
1490
1491 for i in 1..=max_ord {
1492 match i {
1493 2 => {
1494 if let Some(value) = self.payload.take() {
1495 ::fidl_next::wire::Envelope::encode_value::<
1496 crate::wire::EventPayload<'static>,
1497 ___E,
1498 >(
1499 value, preallocated.encoder, &mut out, ()
1500 )?;
1501 } else {
1502 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1503 }
1504 }
1505
1506 1 => {
1507 if let Some(value) = self.header.take() {
1508 ::fidl_next::wire::Envelope::encode_value::<
1509 crate::wire::EventHeader<'static>,
1510 ___E,
1511 >(
1512 value, preallocated.encoder, &mut out, ()
1513 )?;
1514 } else {
1515 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1516 }
1517 }
1518
1519 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1520 }
1521 unsafe {
1522 preallocated.write_next(out.assume_init_ref());
1523 }
1524 }
1525
1526 ::fidl_next::wire::Table::encode_len(table, max_ord);
1527
1528 Ok(())
1529 }
1530 }
1531
1532 impl<'de> ::fidl_next::FromWire<crate::wire::Event<'de>> for Event {
1533 #[inline]
1534 fn from_wire(wire_: crate::wire::Event<'de>) -> Self {
1535 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1536
1537 let header = wire_.table.get(1);
1538
1539 let payload = wire_.table.get(2);
1540
1541 Self {
1542 header: header.map(|envelope| {
1543 ::fidl_next::FromWire::from_wire(unsafe {
1544 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
1545 })
1546 }),
1547
1548 payload: payload.map(|envelope| {
1549 ::fidl_next::FromWire::from_wire(unsafe {
1550 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
1551 })
1552 }),
1553 }
1554 }
1555 }
1556
1557 #[derive(Debug, PartialEq)]
1558 pub struct EventStreamGetNextResponse {
1559 pub events: ::std::vec::Vec<crate::natural::Event>,
1560 }
1561
1562 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
1563 for EventStreamGetNextResponse
1564 where
1565 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1566 ___E: ::fidl_next::Encoder,
1567 ___E: ::fidl_next::fuchsia::HandleEncoder,
1568 {
1569 #[inline]
1570 fn encode(
1571 self,
1572 encoder_: &mut ___E,
1573 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
1574 _: (),
1575 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1576 ::fidl_next::munge! {
1577 let crate::wire::EventStreamGetNextResponse {
1578 events,
1579
1580 } = out_;
1581 }
1582
1583 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
1584
1585 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(events.as_mut_ptr()) };
1586 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1587
1588 Ok(())
1589 }
1590 }
1591
1592 unsafe impl<___E>
1593 ::fidl_next::EncodeOption<
1594 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1595 ___E,
1596 > for EventStreamGetNextResponse
1597 where
1598 ___E: ::fidl_next::Encoder + ?Sized,
1599 EventStreamGetNextResponse:
1600 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>,
1601 {
1602 #[inline]
1603 fn encode_option(
1604 this: ::core::option::Option<Self>,
1605 encoder: &mut ___E,
1606 out: &mut ::core::mem::MaybeUninit<
1607 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1608 >,
1609 _: (),
1610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1611 if let Some(inner) = this {
1612 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1613 ::fidl_next::wire::Box::encode_present(out);
1614 } else {
1615 ::fidl_next::wire::Box::encode_absent(out);
1616 }
1617
1618 Ok(())
1619 }
1620 }
1621
1622 impl<'de> ::fidl_next::FromWire<crate::wire::EventStreamGetNextResponse<'de>>
1623 for EventStreamGetNextResponse
1624 {
1625 #[inline]
1626 fn from_wire(wire: crate::wire::EventStreamGetNextResponse<'de>) -> Self {
1627 Self { events: ::fidl_next::FromWire::from_wire(wire.events) }
1628 }
1629 }
1630
1631 #[derive(Debug, PartialEq)]
1632 #[repr(C)]
1633 pub struct IntrospectorGetMonikerRequest {
1634 pub component_instance: ::fidl_next::fuchsia::zx::Event,
1635 }
1636
1637 unsafe impl<___E> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
1638 for IntrospectorGetMonikerRequest
1639 where
1640 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1641 ___E: ::fidl_next::fuchsia::HandleEncoder,
1642 {
1643 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1644 Self,
1645 crate::wire::IntrospectorGetMonikerRequest,
1646 > = unsafe {
1647 ::fidl_next::CopyOptimization::enable_if(
1648 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
1649 ::fidl_next::wire::fuchsia::Event,
1650 ___E,
1651 >>::COPY_OPTIMIZATION
1652 .is_enabled(),
1653 )
1654 };
1655
1656 #[inline]
1657 fn encode(
1658 self,
1659 encoder_: &mut ___E,
1660 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
1661 _: (),
1662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1663 ::fidl_next::munge! {
1664 let crate::wire::IntrospectorGetMonikerRequest {
1665 component_instance,
1666
1667 } = out_;
1668 }
1669
1670 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
1671
1672 let mut _field =
1673 unsafe { ::fidl_next::Slot::new_unchecked(component_instance.as_mut_ptr()) };
1674
1675 Ok(())
1676 }
1677 }
1678
1679 unsafe impl<___E>
1680 ::fidl_next::EncodeOption<
1681 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1682 ___E,
1683 > for IntrospectorGetMonikerRequest
1684 where
1685 ___E: ::fidl_next::Encoder + ?Sized,
1686 IntrospectorGetMonikerRequest:
1687 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>,
1688 {
1689 #[inline]
1690 fn encode_option(
1691 this: ::core::option::Option<Self>,
1692 encoder: &mut ___E,
1693 out: &mut ::core::mem::MaybeUninit<
1694 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1695 >,
1696 _: (),
1697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1698 if let Some(inner) = this {
1699 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1700 ::fidl_next::wire::Box::encode_present(out);
1701 } else {
1702 ::fidl_next::wire::Box::encode_absent(out);
1703 }
1704
1705 Ok(())
1706 }
1707 }
1708
1709 impl ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerRequest>
1710 for IntrospectorGetMonikerRequest
1711 {
1712 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1713 crate::wire::IntrospectorGetMonikerRequest,
1714 Self,
1715 > = unsafe {
1716 ::fidl_next::CopyOptimization::enable_if(
1717 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
1718 ::fidl_next::wire::fuchsia::Event,
1719 >>::COPY_OPTIMIZATION
1720 .is_enabled(),
1721 )
1722 };
1723
1724 #[inline]
1725 fn from_wire(wire: crate::wire::IntrospectorGetMonikerRequest) -> Self {
1726 Self { component_instance: ::fidl_next::FromWire::from_wire(wire.component_instance) }
1727 }
1728 }
1729
1730 #[derive(Debug, PartialEq)]
1731 pub struct NamespaceInputEntry {
1732 pub path: ::std::string::String,
1733
1734 pub dictionary: ::fidl_next::ClientEnd<
1735 ::fidl_next_fuchsia_component_sandbox::Dictionary,
1736 ::fidl_next::fuchsia::zx::Channel,
1737 >,
1738 }
1739
1740 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
1741 for NamespaceInputEntry
1742 where
1743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1744 ___E: ::fidl_next::Encoder,
1745 ___E: ::fidl_next::fuchsia::HandleEncoder,
1746 {
1747 #[inline]
1748 fn encode(
1749 self,
1750 encoder_: &mut ___E,
1751 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
1752 _: (),
1753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1754 ::fidl_next::munge! {
1755 let crate::wire::NamespaceInputEntry {
1756 path,
1757 dictionary,
1758
1759 } = out_;
1760 }
1761
1762 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1763
1764 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1765 ::fidl_next::Constrained::validate(_field, 4095)?;
1766
1767 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
1768
1769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
1770
1771 Ok(())
1772 }
1773 }
1774
1775 unsafe impl<___E>
1776 ::fidl_next::EncodeOption<
1777 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1778 ___E,
1779 > for NamespaceInputEntry
1780 where
1781 ___E: ::fidl_next::Encoder + ?Sized,
1782 NamespaceInputEntry: ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1790 >,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 if let Some(inner) = this {
1794 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1795 ::fidl_next::wire::Box::encode_present(out);
1796 } else {
1797 ::fidl_next::wire::Box::encode_absent(out);
1798 }
1799
1800 Ok(())
1801 }
1802 }
1803
1804 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry<'de>> for NamespaceInputEntry {
1805 #[inline]
1806 fn from_wire(wire: crate::wire::NamespaceInputEntry<'de>) -> Self {
1807 Self {
1808 path: ::fidl_next::FromWire::from_wire(wire.path),
1809
1810 dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary),
1811 }
1812 }
1813 }
1814
1815 #[derive(Debug, PartialEq)]
1816 pub struct NamespaceCreateRequest {
1817 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry>,
1818 }
1819
1820 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
1821 for NamespaceCreateRequest
1822 where
1823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1824 ___E: ::fidl_next::Encoder,
1825 ___E: ::fidl_next::fuchsia::HandleEncoder,
1826 {
1827 #[inline]
1828 fn encode(
1829 self,
1830 encoder_: &mut ___E,
1831 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
1832 _: (),
1833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1834 ::fidl_next::munge! {
1835 let crate::wire::NamespaceCreateRequest {
1836 entries,
1837
1838 } = out_;
1839 }
1840
1841 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1842
1843 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
1844 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1845
1846 Ok(())
1847 }
1848 }
1849
1850 unsafe impl<___E>
1851 ::fidl_next::EncodeOption<
1852 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1853 ___E,
1854 > for NamespaceCreateRequest
1855 where
1856 ___E: ::fidl_next::Encoder + ?Sized,
1857 NamespaceCreateRequest:
1858 ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>,
1859 {
1860 #[inline]
1861 fn encode_option(
1862 this: ::core::option::Option<Self>,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<
1865 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1866 >,
1867 _: (),
1868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1869 if let Some(inner) = this {
1870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1871 ::fidl_next::wire::Box::encode_present(out);
1872 } else {
1873 ::fidl_next::wire::Box::encode_absent(out);
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateRequest<'de>>
1881 for NamespaceCreateRequest
1882 {
1883 #[inline]
1884 fn from_wire(wire: crate::wire::NamespaceCreateRequest<'de>) -> Self {
1885 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
1886 }
1887 }
1888
1889 #[derive(Debug, PartialEq)]
1890 pub struct NamespaceInputEntry2 {
1891 pub path: ::std::string::String,
1892
1893 pub capability: ::fidl_next::fuchsia::zx::EventPair,
1894 }
1895
1896 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
1897 for NamespaceInputEntry2
1898 where
1899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1900 ___E: ::fidl_next::Encoder,
1901 ___E: ::fidl_next::fuchsia::HandleEncoder,
1902 {
1903 #[inline]
1904 fn encode(
1905 self,
1906 encoder_: &mut ___E,
1907 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge! {
1911 let crate::wire::NamespaceInputEntry2 {
1912 path,
1913 capability,
1914
1915 } = out_;
1916 }
1917
1918 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1919
1920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1921 ::fidl_next::Constrained::validate(_field, 4095)?;
1922
1923 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1924
1925 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1926
1927 Ok(())
1928 }
1929 }
1930
1931 unsafe impl<___E>
1932 ::fidl_next::EncodeOption<
1933 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1934 ___E,
1935 > for NamespaceInputEntry2
1936 where
1937 ___E: ::fidl_next::Encoder + ?Sized,
1938 NamespaceInputEntry2: ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>,
1939 {
1940 #[inline]
1941 fn encode_option(
1942 this: ::core::option::Option<Self>,
1943 encoder: &mut ___E,
1944 out: &mut ::core::mem::MaybeUninit<
1945 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1946 >,
1947 _: (),
1948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1949 if let Some(inner) = this {
1950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1951 ::fidl_next::wire::Box::encode_present(out);
1952 } else {
1953 ::fidl_next::wire::Box::encode_absent(out);
1954 }
1955
1956 Ok(())
1957 }
1958 }
1959
1960 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry2<'de>> for NamespaceInputEntry2 {
1961 #[inline]
1962 fn from_wire(wire: crate::wire::NamespaceInputEntry2<'de>) -> Self {
1963 Self {
1964 path: ::fidl_next::FromWire::from_wire(wire.path),
1965
1966 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1967 }
1968 }
1969 }
1970
1971 #[derive(Debug, PartialEq)]
1972 pub struct NamespaceCreate2Request {
1973 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry2>,
1974 }
1975
1976 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
1977 for NamespaceCreate2Request
1978 where
1979 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1980 ___E: ::fidl_next::Encoder,
1981 ___E: ::fidl_next::fuchsia::HandleEncoder,
1982 {
1983 #[inline]
1984 fn encode(
1985 self,
1986 encoder_: &mut ___E,
1987 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
1988 _: (),
1989 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1990 ::fidl_next::munge! {
1991 let crate::wire::NamespaceCreate2Request {
1992 entries,
1993
1994 } = out_;
1995 }
1996
1997 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1998
1999 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2000 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2001
2002 Ok(())
2003 }
2004 }
2005
2006 unsafe impl<___E>
2007 ::fidl_next::EncodeOption<
2008 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2009 ___E,
2010 > for NamespaceCreate2Request
2011 where
2012 ___E: ::fidl_next::Encoder + ?Sized,
2013 NamespaceCreate2Request:
2014 ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>,
2015 {
2016 #[inline]
2017 fn encode_option(
2018 this: ::core::option::Option<Self>,
2019 encoder: &mut ___E,
2020 out: &mut ::core::mem::MaybeUninit<
2021 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2022 >,
2023 _: (),
2024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2025 if let Some(inner) = this {
2026 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2027 ::fidl_next::wire::Box::encode_present(out);
2028 } else {
2029 ::fidl_next::wire::Box::encode_absent(out);
2030 }
2031
2032 Ok(())
2033 }
2034 }
2035
2036 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Request<'de>>
2037 for NamespaceCreate2Request
2038 {
2039 #[inline]
2040 fn from_wire(wire: crate::wire::NamespaceCreate2Request<'de>) -> Self {
2041 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2042 }
2043 }
2044
2045 #[derive(Debug, PartialEq)]
2046 pub struct NamespaceCreateResponse {
2047 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2048 }
2049
2050 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
2051 for NamespaceCreateResponse
2052 where
2053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2054 ___E: ::fidl_next::Encoder,
2055 ___E: ::fidl_next::fuchsia::HandleEncoder,
2056 {
2057 #[inline]
2058 fn encode(
2059 self,
2060 encoder_: &mut ___E,
2061 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2064 ::fidl_next::munge! {
2065 let crate::wire::NamespaceCreateResponse {
2066 entries,
2067
2068 } = out_;
2069 }
2070
2071 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2072
2073 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2074 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<___E>
2081 ::fidl_next::EncodeOption<
2082 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2083 ___E,
2084 > for NamespaceCreateResponse
2085 where
2086 ___E: ::fidl_next::Encoder + ?Sized,
2087 NamespaceCreateResponse:
2088 ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>,
2089 {
2090 #[inline]
2091 fn encode_option(
2092 this: ::core::option::Option<Self>,
2093 encoder: &mut ___E,
2094 out: &mut ::core::mem::MaybeUninit<
2095 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2096 >,
2097 _: (),
2098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2099 if let Some(inner) = this {
2100 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2101 ::fidl_next::wire::Box::encode_present(out);
2102 } else {
2103 ::fidl_next::wire::Box::encode_absent(out);
2104 }
2105
2106 Ok(())
2107 }
2108 }
2109
2110 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateResponse<'de>>
2111 for NamespaceCreateResponse
2112 {
2113 #[inline]
2114 fn from_wire(wire: crate::wire::NamespaceCreateResponse<'de>) -> Self {
2115 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2116 }
2117 }
2118
2119 #[derive(Debug, PartialEq)]
2120 pub struct NamespaceCreate2Response {
2121 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2122 }
2123
2124 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
2125 for NamespaceCreate2Response
2126 where
2127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2128 ___E: ::fidl_next::Encoder,
2129 ___E: ::fidl_next::fuchsia::HandleEncoder,
2130 {
2131 #[inline]
2132 fn encode(
2133 self,
2134 encoder_: &mut ___E,
2135 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
2136 _: (),
2137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2138 ::fidl_next::munge! {
2139 let crate::wire::NamespaceCreate2Response {
2140 entries,
2141
2142 } = out_;
2143 }
2144
2145 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2146
2147 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2148 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2149
2150 Ok(())
2151 }
2152 }
2153
2154 unsafe impl<___E>
2155 ::fidl_next::EncodeOption<
2156 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2157 ___E,
2158 > for NamespaceCreate2Response
2159 where
2160 ___E: ::fidl_next::Encoder + ?Sized,
2161 NamespaceCreate2Response:
2162 ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>,
2163 {
2164 #[inline]
2165 fn encode_option(
2166 this: ::core::option::Option<Self>,
2167 encoder: &mut ___E,
2168 out: &mut ::core::mem::MaybeUninit<
2169 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2170 >,
2171 _: (),
2172 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2173 if let Some(inner) = this {
2174 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2175 ::fidl_next::wire::Box::encode_present(out);
2176 } else {
2177 ::fidl_next::wire::Box::encode_absent(out);
2178 }
2179
2180 Ok(())
2181 }
2182 }
2183
2184 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Response<'de>>
2185 for NamespaceCreate2Response
2186 {
2187 #[inline]
2188 fn from_wire(wire: crate::wire::NamespaceCreate2Response<'de>) -> Self {
2189 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2190 }
2191 }
2192
2193 #[derive(Debug, PartialEq)]
2194 pub struct RealmListChildrenRequest {
2195 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2196
2197 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::fuchsia::zx::Channel>,
2198 }
2199
2200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
2201 for RealmListChildrenRequest
2202 where
2203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2204 ___E: ::fidl_next::Encoder,
2205 ___E: ::fidl_next::fuchsia::HandleEncoder,
2206 {
2207 #[inline]
2208 fn encode(
2209 self,
2210 encoder_: &mut ___E,
2211 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
2212 _: (),
2213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2214 ::fidl_next::munge! {
2215 let crate::wire::RealmListChildrenRequest {
2216 collection,
2217 iter,
2218
2219 } = out_;
2220 }
2221
2222 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2223
2224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2225
2226 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
2227
2228 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iter.as_mut_ptr()) };
2229
2230 Ok(())
2231 }
2232 }
2233
2234 unsafe impl<___E>
2235 ::fidl_next::EncodeOption<
2236 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2237 ___E,
2238 > for RealmListChildrenRequest
2239 where
2240 ___E: ::fidl_next::Encoder + ?Sized,
2241 RealmListChildrenRequest:
2242 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>,
2243 {
2244 #[inline]
2245 fn encode_option(
2246 this: ::core::option::Option<Self>,
2247 encoder: &mut ___E,
2248 out: &mut ::core::mem::MaybeUninit<
2249 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2250 >,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 if let Some(inner) = this {
2254 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2255 ::fidl_next::wire::Box::encode_present(out);
2256 } else {
2257 ::fidl_next::wire::Box::encode_absent(out);
2258 }
2259
2260 Ok(())
2261 }
2262 }
2263
2264 impl<'de> ::fidl_next::FromWire<crate::wire::RealmListChildrenRequest<'de>>
2265 for RealmListChildrenRequest
2266 {
2267 #[inline]
2268 fn from_wire(wire: crate::wire::RealmListChildrenRequest<'de>) -> Self {
2269 Self {
2270 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2271
2272 iter: ::fidl_next::FromWire::from_wire(wire.iter),
2273 }
2274 }
2275 }
2276
2277 #[derive(Debug, Clone, PartialEq)]
2278 pub struct RealmGetChildOutputDictionaryDeprecatedRequest {
2279 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2280 }
2281
2282 unsafe impl<___E>
2283 ::fidl_next::Encode<
2284 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2285 ___E,
2286 > for RealmGetChildOutputDictionaryDeprecatedRequest
2287 where
2288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2289 ___E: ::fidl_next::Encoder,
2290 ___E: ::fidl_next::fuchsia::HandleEncoder,
2291 {
2292 #[inline]
2293 fn encode(
2294 self,
2295 encoder_: &mut ___E,
2296 out_: &mut ::core::mem::MaybeUninit<
2297 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2298 >,
2299 _: (),
2300 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2301 ::fidl_next::munge! {
2302 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
2303 child,
2304
2305 } = out_;
2306 }
2307
2308 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2309
2310 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2311
2312 Ok(())
2313 }
2314 }
2315
2316 unsafe impl<___E>
2317 ::fidl_next::EncodeOption<
2318 ::fidl_next::wire::Box<
2319 'static,
2320 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2321 >,
2322 ___E,
2323 > for RealmGetChildOutputDictionaryDeprecatedRequest
2324 where
2325 ___E: ::fidl_next::Encoder + ?Sized,
2326 RealmGetChildOutputDictionaryDeprecatedRequest: ::fidl_next::Encode<
2327 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2328 ___E,
2329 >,
2330 {
2331 #[inline]
2332 fn encode_option(
2333 this: ::core::option::Option<Self>,
2334 encoder: &mut ___E,
2335 out: &mut ::core::mem::MaybeUninit<
2336 ::fidl_next::wire::Box<
2337 'static,
2338 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2339 >,
2340 >,
2341 _: (),
2342 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2343 if let Some(inner) = this {
2344 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2345 ::fidl_next::wire::Box::encode_present(out);
2346 } else {
2347 ::fidl_next::wire::Box::encode_absent(out);
2348 }
2349
2350 Ok(())
2351 }
2352 }
2353
2354 impl<'de>
2355 ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>>
2356 for RealmGetChildOutputDictionaryDeprecatedRequest
2357 {
2358 #[inline]
2359 fn from_wire(
2360 wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>,
2361 ) -> Self {
2362 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2363 }
2364 }
2365
2366 #[derive(Debug, PartialEq)]
2367 #[repr(C)]
2368 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
2369 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
2370 }
2371
2372 unsafe impl<___E>
2373 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
2374 for RealmGetChildOutputDictionaryDeprecatedResponse
2375 where
2376 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2377 ___E: ::fidl_next::fuchsia::HandleEncoder,
2378 {
2379 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2380 Self,
2381 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2382 > = unsafe {
2383 ::fidl_next::CopyOptimization::enable_if(
2384 true
2385
2386 && <
2387 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
2388 >::COPY_OPTIMIZATION.is_enabled()
2389
2390 )
2391 };
2392
2393 #[inline]
2394 fn encode(
2395 self,
2396 encoder_: &mut ___E,
2397 out_: &mut ::core::mem::MaybeUninit<
2398 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2399 >,
2400 _: (),
2401 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2402 ::fidl_next::munge! {
2403 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
2404 dictionary,
2405
2406 } = out_;
2407 }
2408
2409 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2410
2411 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2412
2413 Ok(())
2414 }
2415 }
2416
2417 unsafe impl<___E>
2418 ::fidl_next::EncodeOption<
2419 ::fidl_next::wire::Box<
2420 'static,
2421 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2422 >,
2423 ___E,
2424 > for RealmGetChildOutputDictionaryDeprecatedResponse
2425 where
2426 ___E: ::fidl_next::Encoder + ?Sized,
2427 RealmGetChildOutputDictionaryDeprecatedResponse:
2428 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>,
2429 {
2430 #[inline]
2431 fn encode_option(
2432 this: ::core::option::Option<Self>,
2433 encoder: &mut ___E,
2434 out: &mut ::core::mem::MaybeUninit<
2435 ::fidl_next::wire::Box<
2436 'static,
2437 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2438 >,
2439 >,
2440 _: (),
2441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2442 if let Some(inner) = this {
2443 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2444 ::fidl_next::wire::Box::encode_present(out);
2445 } else {
2446 ::fidl_next::wire::Box::encode_absent(out);
2447 }
2448
2449 Ok(())
2450 }
2451 }
2452
2453 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse>
2454 for RealmGetChildOutputDictionaryDeprecatedResponse
2455 {
2456 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2457 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2458 Self,
2459 > = unsafe {
2460 ::fidl_next::CopyOptimization::enable_if(
2461 true
2462
2463 && <
2464 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
2465 >::COPY_OPTIMIZATION.is_enabled()
2466
2467 )
2468 };
2469
2470 #[inline]
2471 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse) -> Self {
2472 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2473 }
2474 }
2475
2476 #[derive(Debug, Clone, PartialEq)]
2477 pub struct RealmGetChildOutputDictionaryRequest {
2478 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2479 }
2480
2481 unsafe impl<___E>
2482 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
2483 for RealmGetChildOutputDictionaryRequest
2484 where
2485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2486 ___E: ::fidl_next::Encoder,
2487 ___E: ::fidl_next::fuchsia::HandleEncoder,
2488 {
2489 #[inline]
2490 fn encode(
2491 self,
2492 encoder_: &mut ___E,
2493 out_: &mut ::core::mem::MaybeUninit<
2494 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2495 >,
2496 _: (),
2497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2498 ::fidl_next::munge! {
2499 let crate::wire::RealmGetChildOutputDictionaryRequest {
2500 child,
2501
2502 } = out_;
2503 }
2504
2505 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2506
2507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2508
2509 Ok(())
2510 }
2511 }
2512
2513 unsafe impl<___E>
2514 ::fidl_next::EncodeOption<
2515 ::fidl_next::wire::Box<
2516 'static,
2517 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2518 >,
2519 ___E,
2520 > for RealmGetChildOutputDictionaryRequest
2521 where
2522 ___E: ::fidl_next::Encoder + ?Sized,
2523 RealmGetChildOutputDictionaryRequest:
2524 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>,
2525 {
2526 #[inline]
2527 fn encode_option(
2528 this: ::core::option::Option<Self>,
2529 encoder: &mut ___E,
2530 out: &mut ::core::mem::MaybeUninit<
2531 ::fidl_next::wire::Box<
2532 'static,
2533 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2534 >,
2535 >,
2536 _: (),
2537 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2538 if let Some(inner) = this {
2539 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2540 ::fidl_next::wire::Box::encode_present(out);
2541 } else {
2542 ::fidl_next::wire::Box::encode_absent(out);
2543 }
2544
2545 Ok(())
2546 }
2547 }
2548
2549 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryRequest<'de>>
2550 for RealmGetChildOutputDictionaryRequest
2551 {
2552 #[inline]
2553 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryRequest<'de>) -> Self {
2554 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2555 }
2556 }
2557
2558 #[derive(Debug, PartialEq)]
2559 #[repr(C)]
2560 pub struct RealmGetChildOutputDictionaryResponse {
2561 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
2562 }
2563
2564 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
2565 for RealmGetChildOutputDictionaryResponse
2566 where
2567 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2568 ___E: ::fidl_next::fuchsia::HandleEncoder,
2569 {
2570 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2571 Self,
2572 crate::wire::RealmGetChildOutputDictionaryResponse,
2573 > = unsafe {
2574 ::fidl_next::CopyOptimization::enable_if(
2575 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2576 ::fidl_next::wire::fuchsia::EventPair,
2577 ___E,
2578 >>::COPY_OPTIMIZATION
2579 .is_enabled(),
2580 )
2581 };
2582
2583 #[inline]
2584 fn encode(
2585 self,
2586 encoder_: &mut ___E,
2587 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 ::fidl_next::munge! {
2591 let crate::wire::RealmGetChildOutputDictionaryResponse {
2592 dictionary,
2593
2594 } = out_;
2595 }
2596
2597 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2598
2599 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2600
2601 Ok(())
2602 }
2603 }
2604
2605 unsafe impl<___E>
2606 ::fidl_next::EncodeOption<
2607 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2608 ___E,
2609 > for RealmGetChildOutputDictionaryResponse
2610 where
2611 ___E: ::fidl_next::Encoder + ?Sized,
2612 RealmGetChildOutputDictionaryResponse:
2613 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>,
2614 {
2615 #[inline]
2616 fn encode_option(
2617 this: ::core::option::Option<Self>,
2618 encoder: &mut ___E,
2619 out: &mut ::core::mem::MaybeUninit<
2620 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2621 >,
2622 _: (),
2623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2624 if let Some(inner) = this {
2625 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2626 ::fidl_next::wire::Box::encode_present(out);
2627 } else {
2628 ::fidl_next::wire::Box::encode_absent(out);
2629 }
2630
2631 Ok(())
2632 }
2633 }
2634
2635 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryResponse>
2636 for RealmGetChildOutputDictionaryResponse
2637 {
2638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2639 crate::wire::RealmGetChildOutputDictionaryResponse,
2640 Self,
2641 > = unsafe {
2642 ::fidl_next::CopyOptimization::enable_if(
2643 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2644 ::fidl_next::wire::fuchsia::EventPair,
2645 >>::COPY_OPTIMIZATION
2646 .is_enabled(),
2647 )
2648 };
2649
2650 #[inline]
2651 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryResponse) -> Self {
2652 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2653 }
2654 }
2655
2656 #[derive(Debug, PartialEq)]
2657 pub struct RealmOpenControllerRequest {
2658 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2659
2660 pub controller:
2661 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
2662 }
2663
2664 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
2665 for RealmOpenControllerRequest
2666 where
2667 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2668 ___E: ::fidl_next::Encoder,
2669 ___E: ::fidl_next::fuchsia::HandleEncoder,
2670 {
2671 #[inline]
2672 fn encode(
2673 self,
2674 encoder_: &mut ___E,
2675 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
2676 _: (),
2677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2678 ::fidl_next::munge! {
2679 let crate::wire::RealmOpenControllerRequest {
2680 child,
2681 controller,
2682
2683 } = out_;
2684 }
2685
2686 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2687
2688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2689
2690 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
2691
2692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(controller.as_mut_ptr()) };
2693
2694 Ok(())
2695 }
2696 }
2697
2698 unsafe impl<___E>
2699 ::fidl_next::EncodeOption<
2700 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2701 ___E,
2702 > for RealmOpenControllerRequest
2703 where
2704 ___E: ::fidl_next::Encoder + ?Sized,
2705 RealmOpenControllerRequest:
2706 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>,
2707 {
2708 #[inline]
2709 fn encode_option(
2710 this: ::core::option::Option<Self>,
2711 encoder: &mut ___E,
2712 out: &mut ::core::mem::MaybeUninit<
2713 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2714 >,
2715 _: (),
2716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2717 if let Some(inner) = this {
2718 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2719 ::fidl_next::wire::Box::encode_present(out);
2720 } else {
2721 ::fidl_next::wire::Box::encode_absent(out);
2722 }
2723
2724 Ok(())
2725 }
2726 }
2727
2728 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenControllerRequest<'de>>
2729 for RealmOpenControllerRequest
2730 {
2731 #[inline]
2732 fn from_wire(wire: crate::wire::RealmOpenControllerRequest<'de>) -> Self {
2733 Self {
2734 child: ::fidl_next::FromWire::from_wire(wire.child),
2735
2736 controller: ::fidl_next::FromWire::from_wire(wire.controller),
2737 }
2738 }
2739 }
2740
2741 #[derive(Debug, PartialEq)]
2742 pub struct RealmOpenExposedDirRequest {
2743 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2744
2745 pub exposed_dir: ::fidl_next::ServerEnd<
2746 ::fidl_next_fuchsia_io::Directory,
2747 ::fidl_next::fuchsia::zx::Channel,
2748 >,
2749 }
2750
2751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
2752 for RealmOpenExposedDirRequest
2753 where
2754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2755 ___E: ::fidl_next::Encoder,
2756 ___E: ::fidl_next::fuchsia::HandleEncoder,
2757 {
2758 #[inline]
2759 fn encode(
2760 self,
2761 encoder_: &mut ___E,
2762 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
2763 _: (),
2764 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765 ::fidl_next::munge! {
2766 let crate::wire::RealmOpenExposedDirRequest {
2767 child,
2768 exposed_dir,
2769
2770 } = out_;
2771 }
2772
2773 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2774
2775 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2776
2777 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
2778
2779 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
2780
2781 Ok(())
2782 }
2783 }
2784
2785 unsafe impl<___E>
2786 ::fidl_next::EncodeOption<
2787 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2788 ___E,
2789 > for RealmOpenExposedDirRequest
2790 where
2791 ___E: ::fidl_next::Encoder + ?Sized,
2792 RealmOpenExposedDirRequest:
2793 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>,
2794 {
2795 #[inline]
2796 fn encode_option(
2797 this: ::core::option::Option<Self>,
2798 encoder: &mut ___E,
2799 out: &mut ::core::mem::MaybeUninit<
2800 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2801 >,
2802 _: (),
2803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2804 if let Some(inner) = this {
2805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2806 ::fidl_next::wire::Box::encode_present(out);
2807 } else {
2808 ::fidl_next::wire::Box::encode_absent(out);
2809 }
2810
2811 Ok(())
2812 }
2813 }
2814
2815 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenExposedDirRequest<'de>>
2816 for RealmOpenExposedDirRequest
2817 {
2818 #[inline]
2819 fn from_wire(wire: crate::wire::RealmOpenExposedDirRequest<'de>) -> Self {
2820 Self {
2821 child: ::fidl_next::FromWire::from_wire(wire.child),
2822
2823 exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir),
2824 }
2825 }
2826 }
2827
2828 #[derive(Debug, PartialEq)]
2829 pub struct RealmCreateChildRequest {
2830 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2831
2832 pub decl: ::fidl_next_fuchsia_component_decl::natural::Child,
2833
2834 pub args: crate::natural::CreateChildArgs,
2835 }
2836
2837 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
2838 for RealmCreateChildRequest
2839 where
2840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2841 ___E: ::fidl_next::Encoder,
2842 ___E: ::fidl_next::fuchsia::HandleEncoder,
2843 {
2844 #[inline]
2845 fn encode(
2846 self,
2847 encoder_: &mut ___E,
2848 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
2849 _: (),
2850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2851 ::fidl_next::munge! {
2852 let crate::wire::RealmCreateChildRequest {
2853 collection,
2854 decl,
2855 args,
2856
2857 } = out_;
2858 }
2859
2860 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2861
2862 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2863
2864 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
2865
2866 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(decl.as_mut_ptr()) };
2867
2868 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
2869
2870 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
2871
2872 Ok(())
2873 }
2874 }
2875
2876 unsafe impl<___E>
2877 ::fidl_next::EncodeOption<
2878 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2879 ___E,
2880 > for RealmCreateChildRequest
2881 where
2882 ___E: ::fidl_next::Encoder + ?Sized,
2883 RealmCreateChildRequest:
2884 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>,
2885 {
2886 #[inline]
2887 fn encode_option(
2888 this: ::core::option::Option<Self>,
2889 encoder: &mut ___E,
2890 out: &mut ::core::mem::MaybeUninit<
2891 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2892 >,
2893 _: (),
2894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2895 if let Some(inner) = this {
2896 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2897 ::fidl_next::wire::Box::encode_present(out);
2898 } else {
2899 ::fidl_next::wire::Box::encode_absent(out);
2900 }
2901
2902 Ok(())
2903 }
2904 }
2905
2906 impl<'de> ::fidl_next::FromWire<crate::wire::RealmCreateChildRequest<'de>>
2907 for RealmCreateChildRequest
2908 {
2909 #[inline]
2910 fn from_wire(wire: crate::wire::RealmCreateChildRequest<'de>) -> Self {
2911 Self {
2912 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2913
2914 decl: ::fidl_next::FromWire::from_wire(wire.decl),
2915
2916 args: ::fidl_next::FromWire::from_wire(wire.args),
2917 }
2918 }
2919 }
2920
2921 #[derive(Debug, PartialEq)]
2922 pub struct RealmGetResolvedInfoResponse {
2923 pub resolved_info: ::fidl_next_fuchsia_component_resolution::natural::Component,
2924 }
2925
2926 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
2927 for RealmGetResolvedInfoResponse
2928 where
2929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2930 ___E: ::fidl_next::Encoder,
2931 ___E: ::fidl_next::fuchsia::HandleEncoder,
2932 {
2933 #[inline]
2934 fn encode(
2935 self,
2936 encoder_: &mut ___E,
2937 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
2938 _: (),
2939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940 ::fidl_next::munge! {
2941 let crate::wire::RealmGetResolvedInfoResponse {
2942 resolved_info,
2943
2944 } = out_;
2945 }
2946
2947 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
2948
2949 let mut _field =
2950 unsafe { ::fidl_next::Slot::new_unchecked(resolved_info.as_mut_ptr()) };
2951
2952 Ok(())
2953 }
2954 }
2955
2956 unsafe impl<___E>
2957 ::fidl_next::EncodeOption<
2958 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2959 ___E,
2960 > for RealmGetResolvedInfoResponse
2961 where
2962 ___E: ::fidl_next::Encoder + ?Sized,
2963 RealmGetResolvedInfoResponse:
2964 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>,
2965 {
2966 #[inline]
2967 fn encode_option(
2968 this: ::core::option::Option<Self>,
2969 encoder: &mut ___E,
2970 out: &mut ::core::mem::MaybeUninit<
2971 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2972 >,
2973 _: (),
2974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2975 if let Some(inner) = this {
2976 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2977 ::fidl_next::wire::Box::encode_present(out);
2978 } else {
2979 ::fidl_next::wire::Box::encode_absent(out);
2980 }
2981
2982 Ok(())
2983 }
2984 }
2985
2986 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetResolvedInfoResponse<'de>>
2987 for RealmGetResolvedInfoResponse
2988 {
2989 #[inline]
2990 fn from_wire(wire: crate::wire::RealmGetResolvedInfoResponse<'de>) -> Self {
2991 Self { resolved_info: ::fidl_next::FromWire::from_wire(wire.resolved_info) }
2992 }
2993 }
2994
2995 #[derive(Debug, PartialEq)]
2996 pub struct StorageAdminListStorageInRealmRequest {
2997 pub relative_moniker: ::std::string::String,
2998
2999 pub iterator:
3000 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::fuchsia::zx::Channel>,
3001 }
3002
3003 unsafe impl<___E>
3004 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
3005 for StorageAdminListStorageInRealmRequest
3006 where
3007 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3008 ___E: ::fidl_next::Encoder,
3009 ___E: ::fidl_next::fuchsia::HandleEncoder,
3010 {
3011 #[inline]
3012 fn encode(
3013 self,
3014 encoder_: &mut ___E,
3015 out_: &mut ::core::mem::MaybeUninit<
3016 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3017 >,
3018 _: (),
3019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3020 ::fidl_next::munge! {
3021 let crate::wire::StorageAdminListStorageInRealmRequest {
3022 relative_moniker,
3023 iterator,
3024
3025 } = out_;
3026 }
3027
3028 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3029
3030 let mut _field =
3031 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3032 ::fidl_next::Constrained::validate(_field, 4096)?;
3033
3034 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
3035
3036 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
3037
3038 Ok(())
3039 }
3040 }
3041
3042 unsafe impl<___E>
3043 ::fidl_next::EncodeOption<
3044 ::fidl_next::wire::Box<
3045 'static,
3046 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3047 >,
3048 ___E,
3049 > for StorageAdminListStorageInRealmRequest
3050 where
3051 ___E: ::fidl_next::Encoder + ?Sized,
3052 StorageAdminListStorageInRealmRequest:
3053 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>,
3054 {
3055 #[inline]
3056 fn encode_option(
3057 this: ::core::option::Option<Self>,
3058 encoder: &mut ___E,
3059 out: &mut ::core::mem::MaybeUninit<
3060 ::fidl_next::wire::Box<
3061 'static,
3062 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3063 >,
3064 >,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067 if let Some(inner) = this {
3068 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3069 ::fidl_next::wire::Box::encode_present(out);
3070 } else {
3071 ::fidl_next::wire::Box::encode_absent(out);
3072 }
3073
3074 Ok(())
3075 }
3076 }
3077
3078 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminListStorageInRealmRequest<'de>>
3079 for StorageAdminListStorageInRealmRequest
3080 {
3081 #[inline]
3082 fn from_wire(wire: crate::wire::StorageAdminListStorageInRealmRequest<'de>) -> Self {
3083 Self {
3084 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3085
3086 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
3087 }
3088 }
3089 }
3090
3091 #[derive(Debug, PartialEq)]
3092 pub struct StorageAdminOpenStorageRequest {
3093 pub relative_moniker: ::std::string::String,
3094
3095 pub object:
3096 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3097 }
3098
3099 unsafe impl<___E>
3100 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
3101 for StorageAdminOpenStorageRequest
3102 where
3103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3104 ___E: ::fidl_next::Encoder,
3105 ___E: ::fidl_next::fuchsia::HandleEncoder,
3106 {
3107 #[inline]
3108 fn encode(
3109 self,
3110 encoder_: &mut ___E,
3111 out_: &mut ::core::mem::MaybeUninit<
3112 crate::wire::StorageAdminOpenStorageRequest<'static>,
3113 >,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::StorageAdminOpenStorageRequest {
3118 relative_moniker,
3119 object,
3120
3121 } = out_;
3122 }
3123
3124 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3125
3126 let mut _field =
3127 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3128 ::fidl_next::Constrained::validate(_field, 4096)?;
3129
3130 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3131
3132 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3133
3134 Ok(())
3135 }
3136 }
3137
3138 unsafe impl<___E>
3139 ::fidl_next::EncodeOption<
3140 ::fidl_next::wire::Box<'static, crate::wire::StorageAdminOpenStorageRequest<'static>>,
3141 ___E,
3142 > for StorageAdminOpenStorageRequest
3143 where
3144 ___E: ::fidl_next::Encoder + ?Sized,
3145 StorageAdminOpenStorageRequest:
3146 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>,
3147 {
3148 #[inline]
3149 fn encode_option(
3150 this: ::core::option::Option<Self>,
3151 encoder: &mut ___E,
3152 out: &mut ::core::mem::MaybeUninit<
3153 ::fidl_next::wire::Box<
3154 'static,
3155 crate::wire::StorageAdminOpenStorageRequest<'static>,
3156 >,
3157 >,
3158 _: (),
3159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3160 if let Some(inner) = this {
3161 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3162 ::fidl_next::wire::Box::encode_present(out);
3163 } else {
3164 ::fidl_next::wire::Box::encode_absent(out);
3165 }
3166
3167 Ok(())
3168 }
3169 }
3170
3171 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenStorageRequest<'de>>
3172 for StorageAdminOpenStorageRequest
3173 {
3174 #[inline]
3175 fn from_wire(wire: crate::wire::StorageAdminOpenStorageRequest<'de>) -> Self {
3176 Self {
3177 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3178
3179 object: ::fidl_next::FromWire::from_wire(wire.object),
3180 }
3181 }
3182 }
3183
3184 #[derive(Debug, PartialEq)]
3185 pub struct StorageAdminOpenComponentStorageByIdRequest {
3186 pub id: ::std::string::String,
3187
3188 pub object:
3189 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3190 }
3191
3192 unsafe impl<___E>
3193 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
3194 for StorageAdminOpenComponentStorageByIdRequest
3195 where
3196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3197 ___E: ::fidl_next::Encoder,
3198 ___E: ::fidl_next::fuchsia::HandleEncoder,
3199 {
3200 #[inline]
3201 fn encode(
3202 self,
3203 encoder_: &mut ___E,
3204 out_: &mut ::core::mem::MaybeUninit<
3205 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3206 >,
3207 _: (),
3208 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3209 ::fidl_next::munge! {
3210 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
3211 id,
3212 object,
3213
3214 } = out_;
3215 }
3216
3217 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
3218
3219 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3220 ::fidl_next::Constrained::validate(_field, 64)?;
3221
3222 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3223
3224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3225
3226 Ok(())
3227 }
3228 }
3229
3230 unsafe impl<___E>
3231 ::fidl_next::EncodeOption<
3232 ::fidl_next::wire::Box<
3233 'static,
3234 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3235 >,
3236 ___E,
3237 > for StorageAdminOpenComponentStorageByIdRequest
3238 where
3239 ___E: ::fidl_next::Encoder + ?Sized,
3240 StorageAdminOpenComponentStorageByIdRequest: ::fidl_next::Encode<
3241 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3242 ___E,
3243 >,
3244 {
3245 #[inline]
3246 fn encode_option(
3247 this: ::core::option::Option<Self>,
3248 encoder: &mut ___E,
3249 out: &mut ::core::mem::MaybeUninit<
3250 ::fidl_next::wire::Box<
3251 'static,
3252 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3253 >,
3254 >,
3255 _: (),
3256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3257 if let Some(inner) = this {
3258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3259 ::fidl_next::wire::Box::encode_present(out);
3260 } else {
3261 ::fidl_next::wire::Box::encode_absent(out);
3262 }
3263
3264 Ok(())
3265 }
3266 }
3267
3268 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>>
3269 for StorageAdminOpenComponentStorageByIdRequest
3270 {
3271 #[inline]
3272 fn from_wire(wire: crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>) -> Self {
3273 Self {
3274 id: ::fidl_next::FromWire::from_wire(wire.id),
3275
3276 object: ::fidl_next::FromWire::from_wire(wire.object),
3277 }
3278 }
3279 }
3280}
3281
3282pub mod wire {
3283
3284 pub use fidl_next_common_fuchsia_component::wire::*;
3285
3286 #[repr(C)]
3288 pub struct CapabilityRequestedPayload<'de> {
3289 pub(crate) table: ::fidl_next::wire::Table<'de>,
3290 }
3291
3292 impl<'de> Drop for CapabilityRequestedPayload<'de> {
3293 fn drop(&mut self) {
3294 let _ = self.table.get(1).map(|envelope| unsafe {
3295 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3296 });
3297
3298 let _ = self.table.get(2).map(|envelope| unsafe {
3299 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3300 });
3301 }
3302 }
3303
3304 impl ::fidl_next::Constrained for CapabilityRequestedPayload<'_> {
3305 type Constraint = ();
3306
3307 fn validate(
3308 _: ::fidl_next::Slot<'_, Self>,
3309 _: Self::Constraint,
3310 ) -> Result<(), ::fidl_next::ValidationError> {
3311 Ok(())
3312 }
3313 }
3314
3315 unsafe impl ::fidl_next::Wire for CapabilityRequestedPayload<'static> {
3316 type Narrowed<'de> = CapabilityRequestedPayload<'de>;
3317
3318 #[inline]
3319 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3320 ::fidl_next::munge!(let Self { table } = out);
3321 ::fidl_next::wire::Table::zero_padding(table);
3322 }
3323 }
3324
3325 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityRequestedPayload<'de>
3326 where
3327 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3328 ___D: ::fidl_next::fuchsia::HandleDecoder,
3329 {
3330 fn decode(
3331 slot: ::fidl_next::Slot<'_, Self>,
3332 decoder: &mut ___D,
3333 _: (),
3334 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3335 ::fidl_next::munge!(let Self { table } = slot);
3336
3337 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3338 match ordinal {
3339 0 => unsafe { ::core::hint::unreachable_unchecked() },
3340
3341 1 => {
3342 ::fidl_next::wire::Envelope::decode_as::<
3343 ___D,
3344 ::fidl_next::wire::String<'de>,
3345 >(slot.as_mut(), decoder, 255)?;
3346
3347 let value = unsafe {
3348 slot.deref_unchecked()
3349 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3350 };
3351
3352 if value.len() > 255 {
3353 return Err(::fidl_next::DecodeError::VectorTooLong {
3354 size: value.len() as u64,
3355 limit: 255,
3356 });
3357 }
3358
3359 Ok(())
3360 }
3361
3362 2 => {
3363 ::fidl_next::wire::Envelope::decode_as::<
3364 ___D,
3365 ::fidl_next::wire::fuchsia::Channel,
3366 >(slot.as_mut(), decoder, ())?;
3367
3368 Ok(())
3369 }
3370
3371 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3372 }
3373 })
3374 }
3375 }
3376
3377 impl<'de> CapabilityRequestedPayload<'de> {
3378 pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3379 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3380 }
3381
3382 pub fn take_name(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3383 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3384 }
3385
3386 pub fn capability(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
3387 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3388 }
3389
3390 pub fn take_capability(
3391 &mut self,
3392 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::Channel> {
3393 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3394 }
3395 }
3396
3397 impl<'de> ::core::fmt::Debug for CapabilityRequestedPayload<'de> {
3398 fn fmt(
3399 &self,
3400 f: &mut ::core::fmt::Formatter<'_>,
3401 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3402 f.debug_struct("CapabilityRequestedPayload")
3403 .field("name", &self.name())
3404 .field("capability", &self.capability())
3405 .finish()
3406 }
3407 }
3408
3409 impl<'de> ::fidl_next::IntoNatural for CapabilityRequestedPayload<'de> {
3410 type Natural = crate::natural::CapabilityRequestedPayload;
3411 }
3412
3413 #[derive(Debug)]
3415 #[repr(C)]
3416 pub struct ControllerIsStartedResponse {
3417 pub is_started: bool,
3418 }
3419
3420 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerIsStartedResponse>(), 1);
3421 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerIsStartedResponse>(), 1);
3422
3423 static_assertions::const_assert_eq!(
3424 std::mem::offset_of!(ControllerIsStartedResponse, is_started),
3425 0
3426 );
3427
3428 impl ::fidl_next::Constrained for ControllerIsStartedResponse {
3429 type Constraint = ();
3430
3431 fn validate(
3432 _: ::fidl_next::Slot<'_, Self>,
3433 _: Self::Constraint,
3434 ) -> Result<(), ::fidl_next::ValidationError> {
3435 Ok(())
3436 }
3437 }
3438
3439 unsafe impl ::fidl_next::Wire for ControllerIsStartedResponse {
3440 type Narrowed<'de> = ControllerIsStartedResponse;
3441
3442 #[inline]
3443 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3444 ::fidl_next::munge! {
3445 let Self {
3446 is_started,
3447
3448 } = &mut *out_;
3449 }
3450
3451 ::fidl_next::Wire::zero_padding(is_started);
3452 }
3453 }
3454
3455 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerIsStartedResponse
3456 where
3457 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3458 ___D: ::fidl_next::fuchsia::HandleDecoder,
3459 {
3460 fn decode(
3461 slot_: ::fidl_next::Slot<'_, Self>,
3462 decoder_: &mut ___D,
3463 _: (),
3464 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3465 ::fidl_next::munge! {
3466 let Self {
3467 mut is_started,
3468
3469 } = slot_;
3470 }
3471
3472 let _field = is_started.as_mut();
3473
3474 ::fidl_next::Decode::decode(is_started.as_mut(), decoder_, ())?;
3475
3476 Ok(())
3477 }
3478 }
3479
3480 impl ::fidl_next::IntoNatural for ControllerIsStartedResponse {
3481 type Natural = crate::natural::ControllerIsStartedResponse;
3482 }
3483
3484 #[derive(Debug)]
3486 #[repr(C)]
3487 pub struct ControllerGetExposedDictionaryResponse {
3488 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3489 }
3490
3491 static_assertions::const_assert_eq!(
3492 std::mem::size_of::<ControllerGetExposedDictionaryResponse>(),
3493 4
3494 );
3495 static_assertions::const_assert_eq!(
3496 std::mem::align_of::<ControllerGetExposedDictionaryResponse>(),
3497 4
3498 );
3499
3500 static_assertions::const_assert_eq!(
3501 std::mem::offset_of!(ControllerGetExposedDictionaryResponse, dictionary),
3502 0
3503 );
3504
3505 impl ::fidl_next::Constrained for ControllerGetExposedDictionaryResponse {
3506 type Constraint = ();
3507
3508 fn validate(
3509 _: ::fidl_next::Slot<'_, Self>,
3510 _: Self::Constraint,
3511 ) -> Result<(), ::fidl_next::ValidationError> {
3512 Ok(())
3513 }
3514 }
3515
3516 unsafe impl ::fidl_next::Wire for ControllerGetExposedDictionaryResponse {
3517 type Narrowed<'de> = ControllerGetExposedDictionaryResponse;
3518
3519 #[inline]
3520 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3521 ::fidl_next::munge! {
3522 let Self {
3523 dictionary,
3524
3525 } = &mut *out_;
3526 }
3527
3528 ::fidl_next::Wire::zero_padding(dictionary);
3529 }
3530 }
3531
3532 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetExposedDictionaryResponse
3533 where
3534 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3535 ___D: ::fidl_next::fuchsia::HandleDecoder,
3536 {
3537 fn decode(
3538 slot_: ::fidl_next::Slot<'_, Self>,
3539 decoder_: &mut ___D,
3540 _: (),
3541 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3542 ::fidl_next::munge! {
3543 let Self {
3544 mut dictionary,
3545
3546 } = slot_;
3547 }
3548
3549 let _field = dictionary.as_mut();
3550
3551 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3552
3553 Ok(())
3554 }
3555 }
3556
3557 impl ::fidl_next::IntoNatural for ControllerGetExposedDictionaryResponse {
3558 type Natural = crate::natural::ControllerGetExposedDictionaryResponse;
3559 }
3560
3561 #[derive(Debug)]
3563 #[repr(C)]
3564 pub struct ControllerGetOutputDictionaryResponse {
3565 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
3566 }
3567
3568 static_assertions::const_assert_eq!(
3569 std::mem::size_of::<ControllerGetOutputDictionaryResponse>(),
3570 4
3571 );
3572 static_assertions::const_assert_eq!(
3573 std::mem::align_of::<ControllerGetOutputDictionaryResponse>(),
3574 4
3575 );
3576
3577 static_assertions::const_assert_eq!(
3578 std::mem::offset_of!(ControllerGetOutputDictionaryResponse, dictionary),
3579 0
3580 );
3581
3582 impl ::fidl_next::Constrained for ControllerGetOutputDictionaryResponse {
3583 type Constraint = ();
3584
3585 fn validate(
3586 _: ::fidl_next::Slot<'_, Self>,
3587 _: Self::Constraint,
3588 ) -> Result<(), ::fidl_next::ValidationError> {
3589 Ok(())
3590 }
3591 }
3592
3593 unsafe impl ::fidl_next::Wire for ControllerGetOutputDictionaryResponse {
3594 type Narrowed<'de> = ControllerGetOutputDictionaryResponse;
3595
3596 #[inline]
3597 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3598 ::fidl_next::munge! {
3599 let Self {
3600 dictionary,
3601
3602 } = &mut *out_;
3603 }
3604
3605 ::fidl_next::Wire::zero_padding(dictionary);
3606 }
3607 }
3608
3609 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetOutputDictionaryResponse
3610 where
3611 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3612 ___D: ::fidl_next::fuchsia::HandleDecoder,
3613 {
3614 fn decode(
3615 slot_: ::fidl_next::Slot<'_, Self>,
3616 decoder_: &mut ___D,
3617 _: (),
3618 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3619 ::fidl_next::munge! {
3620 let Self {
3621 mut dictionary,
3622
3623 } = slot_;
3624 }
3625
3626 let _field = dictionary.as_mut();
3627
3628 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3629
3630 Ok(())
3631 }
3632 }
3633
3634 impl ::fidl_next::IntoNatural for ControllerGetOutputDictionaryResponse {
3635 type Natural = crate::natural::ControllerGetOutputDictionaryResponse;
3636 }
3637
3638 #[repr(C)]
3640 pub struct NamespaceEntry<'de> {
3641 pub(crate) table: ::fidl_next::wire::Table<'de>,
3642 }
3643
3644 impl<'de> Drop for NamespaceEntry<'de> {
3645 fn drop(&mut self) {
3646 let _ = self.table.get(1).map(|envelope| unsafe {
3647 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3648 });
3649
3650 let _ = self.table.get(2).map(|envelope| unsafe {
3651 envelope.read_unchecked::<::fidl_next::ClientEnd<
3652 ::fidl_next_fuchsia_io::Directory,
3653 ::fidl_next::wire::fuchsia::Channel,
3654 >>()
3655 });
3656 }
3657 }
3658
3659 impl ::fidl_next::Constrained for NamespaceEntry<'_> {
3660 type Constraint = ();
3661
3662 fn validate(
3663 _: ::fidl_next::Slot<'_, Self>,
3664 _: Self::Constraint,
3665 ) -> Result<(), ::fidl_next::ValidationError> {
3666 Ok(())
3667 }
3668 }
3669
3670 unsafe impl ::fidl_next::Wire for NamespaceEntry<'static> {
3671 type Narrowed<'de> = NamespaceEntry<'de>;
3672
3673 #[inline]
3674 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3675 ::fidl_next::munge!(let Self { table } = out);
3676 ::fidl_next::wire::Table::zero_padding(table);
3677 }
3678 }
3679
3680 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceEntry<'de>
3681 where
3682 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3683 ___D: ::fidl_next::fuchsia::HandleDecoder,
3684 {
3685 fn decode(
3686 slot: ::fidl_next::Slot<'_, Self>,
3687 decoder: &mut ___D,
3688 _: (),
3689 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3690 ::fidl_next::munge!(let Self { table } = slot);
3691
3692 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3693 match ordinal {
3694 0 => unsafe { ::core::hint::unreachable_unchecked() },
3695
3696 1 => {
3697 ::fidl_next::wire::Envelope::decode_as::<
3698 ___D,
3699 ::fidl_next::wire::String<'de>,
3700 >(slot.as_mut(), decoder, 4095)?;
3701
3702 let value = unsafe {
3703 slot.deref_unchecked()
3704 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3705 };
3706
3707 if value.len() > 4095 {
3708 return Err(::fidl_next::DecodeError::VectorTooLong {
3709 size: value.len() as u64,
3710 limit: 4095,
3711 });
3712 }
3713
3714 Ok(())
3715 }
3716
3717 2 => {
3718 ::fidl_next::wire::Envelope::decode_as::<
3719 ___D,
3720 ::fidl_next::ClientEnd<
3721 ::fidl_next_fuchsia_io::Directory,
3722 ::fidl_next::wire::fuchsia::Channel,
3723 >,
3724 >(slot.as_mut(), decoder, ())?;
3725
3726 Ok(())
3727 }
3728
3729 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3730 }
3731 })
3732 }
3733 }
3734
3735 impl<'de> NamespaceEntry<'de> {
3736 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3737 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3738 }
3739
3740 pub fn take_path(&mut self) -> ::core::option::Option<::fidl_next::wire::String<'de>> {
3741 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3742 }
3743
3744 pub fn directory(
3745 &self,
3746 ) -> ::core::option::Option<
3747 &::fidl_next::ClientEnd<
3748 ::fidl_next_fuchsia_io::Directory,
3749 ::fidl_next::wire::fuchsia::Channel,
3750 >,
3751 > {
3752 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3753 }
3754
3755 pub fn take_directory(
3756 &mut self,
3757 ) -> ::core::option::Option<
3758 ::fidl_next::ClientEnd<
3759 ::fidl_next_fuchsia_io::Directory,
3760 ::fidl_next::wire::fuchsia::Channel,
3761 >,
3762 > {
3763 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3764 }
3765 }
3766
3767 impl<'de> ::core::fmt::Debug for NamespaceEntry<'de> {
3768 fn fmt(
3769 &self,
3770 f: &mut ::core::fmt::Formatter<'_>,
3771 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3772 f.debug_struct("NamespaceEntry")
3773 .field("path", &self.path())
3774 .field("directory", &self.directory())
3775 .finish()
3776 }
3777 }
3778
3779 impl<'de> ::fidl_next::IntoNatural for NamespaceEntry<'de> {
3780 type Natural = crate::natural::NamespaceEntry;
3781 }
3782
3783 #[repr(C)]
3785 pub struct StartChildArgs<'de> {
3786 pub(crate) table: ::fidl_next::wire::Table<'de>,
3787 }
3788
3789 impl<'de> Drop for StartChildArgs<'de> {
3790 fn drop(&mut self) {
3791 let _ = self.table.get(1).map(|envelope| unsafe {
3792 envelope.read_unchecked::<::fidl_next::wire::Vector<
3793 'de,
3794 ::fidl_next_fuchsia_process::wire::HandleInfo,
3795 >>()
3796 });
3797
3798 let _ = self.table.get(2)
3799 .map(|envelope| unsafe {
3800 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>()
3801 });
3802
3803 let _ = self.table.get(3)
3804 .map(|envelope| unsafe {
3805 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
3806 });
3807
3808 let _ = self.table.get(4).map(|envelope| unsafe {
3809 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
3810 });
3811 }
3812 }
3813
3814 impl ::fidl_next::Constrained for StartChildArgs<'_> {
3815 type Constraint = ();
3816
3817 fn validate(
3818 _: ::fidl_next::Slot<'_, Self>,
3819 _: Self::Constraint,
3820 ) -> Result<(), ::fidl_next::ValidationError> {
3821 Ok(())
3822 }
3823 }
3824
3825 unsafe impl ::fidl_next::Wire for StartChildArgs<'static> {
3826 type Narrowed<'de> = StartChildArgs<'de>;
3827
3828 #[inline]
3829 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3830 ::fidl_next::munge!(let Self { table } = out);
3831 ::fidl_next::wire::Table::zero_padding(table);
3832 }
3833 }
3834
3835 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartChildArgs<'de>
3836 where
3837 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3838 ___D: ::fidl_next::fuchsia::HandleDecoder,
3839 {
3840 fn decode(
3841 slot: ::fidl_next::Slot<'_, Self>,
3842 decoder: &mut ___D,
3843 _: (),
3844 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3845 ::fidl_next::munge!(let Self { table } = slot);
3846
3847 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3848 match ordinal {
3849 0 => unsafe { ::core::hint::unreachable_unchecked() },
3850
3851 1 => {
3852 ::fidl_next::wire::Envelope::decode_as::<
3853 ___D,
3854 ::fidl_next::wire::Vector<
3855 'de,
3856 ::fidl_next_fuchsia_process::wire::HandleInfo,
3857 >,
3858 >(slot.as_mut(), decoder, (128, ()))?;
3859
3860 let value = unsafe {
3861 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
3862 '_,
3863 ::fidl_next_fuchsia_process::wire::HandleInfo,
3864 >>()
3865 };
3866
3867 if value.len() > 128 {
3868 return Err(::fidl_next::DecodeError::VectorTooLong {
3869 size: value.len() as u64,
3870 limit: 128,
3871 });
3872 }
3873
3874 Ok(())
3875 }
3876
3877 2 => {
3878 ::fidl_next::wire::Envelope::decode_as::<
3879 ___D,
3880 ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
3881 >(slot.as_mut(), decoder, (32, ()))?;
3882
3883 let value = unsafe {
3884 slot
3885 .deref_unchecked()
3886 .deref_unchecked::<
3887 ::fidl_next::wire::Vector<'_, crate::wire::NamespaceEntry<'_>>
3888 >()
3889 };
3890
3891 if value.len() > 32 {
3892 return Err(::fidl_next::DecodeError::VectorTooLong {
3893 size: value.len() as u64,
3894 limit: 32,
3895 });
3896 }
3897
3898 Ok(())
3899 }
3900
3901 3 => {
3902 ::fidl_next::wire::Envelope::decode_as::<
3903 ___D,
3904 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3905 >(slot.as_mut(), decoder, ())?;
3906
3907 Ok(())
3908 }
3909
3910 4 => {
3911 ::fidl_next::wire::Envelope::decode_as::<
3912 ___D,
3913 ::fidl_next::wire::fuchsia::EventPair,
3914 >(slot.as_mut(), decoder, ())?;
3915
3916 Ok(())
3917 }
3918
3919 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3920 }
3921 })
3922 }
3923 }
3924
3925 impl<'de> StartChildArgs<'de> {
3926 pub fn numbered_handles(
3927 &self,
3928 ) -> ::core::option::Option<
3929 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3930 > {
3931 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3932 }
3933
3934 pub fn take_numbered_handles(
3935 &mut self,
3936 ) -> ::core::option::Option<
3937 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3938 > {
3939 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
3940 }
3941
3942 pub fn namespace_entries(
3943 &self,
3944 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3945 {
3946 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3947 }
3948
3949 pub fn take_namespace_entries(
3950 &mut self,
3951 ) -> ::core::option::Option<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3952 {
3953 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
3954 }
3955
3956 pub fn dictionary(
3957 &self,
3958 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3959 {
3960 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3961 }
3962
3963 pub fn take_dictionary(
3964 &mut self,
3965 ) -> ::core::option::Option<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3966 {
3967 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
3968 }
3969
3970 pub fn additional_inputs(
3971 &self,
3972 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
3973 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3974 }
3975
3976 pub fn take_additional_inputs(
3977 &mut self,
3978 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
3979 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
3980 }
3981 }
3982
3983 impl<'de> ::core::fmt::Debug for StartChildArgs<'de> {
3984 fn fmt(
3985 &self,
3986 f: &mut ::core::fmt::Formatter<'_>,
3987 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3988 f.debug_struct("StartChildArgs")
3989 .field("numbered_handles", &self.numbered_handles())
3990 .field("namespace_entries", &self.namespace_entries())
3991 .field("dictionary", &self.dictionary())
3992 .field("additional_inputs", &self.additional_inputs())
3993 .finish()
3994 }
3995 }
3996
3997 impl<'de> ::fidl_next::IntoNatural for StartChildArgs<'de> {
3998 type Natural = crate::natural::StartChildArgs;
3999 }
4000
4001 #[derive(Debug)]
4003 #[repr(C)]
4004 pub struct ControllerStartRequest<'de> {
4005 pub args: crate::wire::StartChildArgs<'de>,
4006
4007 pub execution_controller:
4008 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::wire::fuchsia::Channel>,
4009 }
4010
4011 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerStartRequest<'_>>(), 24);
4012 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerStartRequest<'_>>(), 8);
4013
4014 static_assertions::const_assert_eq!(std::mem::offset_of!(ControllerStartRequest<'_>, args), 0);
4015
4016 static_assertions::const_assert_eq!(
4017 std::mem::offset_of!(ControllerStartRequest<'_>, execution_controller),
4018 16
4019 );
4020
4021 impl ::fidl_next::Constrained for ControllerStartRequest<'_> {
4022 type Constraint = ();
4023
4024 fn validate(
4025 _: ::fidl_next::Slot<'_, Self>,
4026 _: Self::Constraint,
4027 ) -> Result<(), ::fidl_next::ValidationError> {
4028 Ok(())
4029 }
4030 }
4031
4032 unsafe impl ::fidl_next::Wire for ControllerStartRequest<'static> {
4033 type Narrowed<'de> = ControllerStartRequest<'de>;
4034
4035 #[inline]
4036 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4037 ::fidl_next::munge! {
4038 let Self {
4039 args,
4040 execution_controller,
4041
4042 } = &mut *out_;
4043 }
4044
4045 ::fidl_next::Wire::zero_padding(args);
4046
4047 ::fidl_next::Wire::zero_padding(execution_controller);
4048
4049 unsafe {
4050 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
4051 }
4052 }
4053 }
4054
4055 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ControllerStartRequest<'de>
4056 where
4057 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4058 ___D: ::fidl_next::Decoder<'de>,
4059 ___D: ::fidl_next::fuchsia::HandleDecoder,
4060 {
4061 fn decode(
4062 slot_: ::fidl_next::Slot<'_, Self>,
4063 decoder_: &mut ___D,
4064 _: (),
4065 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4066 if slot_.as_bytes()[20..24] != [0u8; 4] {
4067 return Err(::fidl_next::DecodeError::InvalidPadding);
4068 }
4069
4070 ::fidl_next::munge! {
4071 let Self {
4072 mut args,
4073 mut execution_controller,
4074
4075 } = slot_;
4076 }
4077
4078 let _field = args.as_mut();
4079
4080 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
4081
4082 let _field = execution_controller.as_mut();
4083
4084 ::fidl_next::Decode::decode(execution_controller.as_mut(), decoder_, ())?;
4085
4086 Ok(())
4087 }
4088 }
4089
4090 impl<'de> ::fidl_next::IntoNatural for ControllerStartRequest<'de> {
4091 type Natural = crate::natural::ControllerStartRequest;
4092 }
4093
4094 #[derive(Debug)]
4096 #[repr(C)]
4097 pub struct ControllerOpenExposedDirRequest {
4098 pub exposed_dir: ::fidl_next::ServerEnd<
4099 ::fidl_next_fuchsia_io::Directory,
4100 ::fidl_next::wire::fuchsia::Channel,
4101 >,
4102 }
4103
4104 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerOpenExposedDirRequest>(), 4);
4105 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerOpenExposedDirRequest>(), 4);
4106
4107 static_assertions::const_assert_eq!(
4108 std::mem::offset_of!(ControllerOpenExposedDirRequest, exposed_dir),
4109 0
4110 );
4111
4112 impl ::fidl_next::Constrained for ControllerOpenExposedDirRequest {
4113 type Constraint = ();
4114
4115 fn validate(
4116 _: ::fidl_next::Slot<'_, Self>,
4117 _: Self::Constraint,
4118 ) -> Result<(), ::fidl_next::ValidationError> {
4119 Ok(())
4120 }
4121 }
4122
4123 unsafe impl ::fidl_next::Wire for ControllerOpenExposedDirRequest {
4124 type Narrowed<'de> = ControllerOpenExposedDirRequest;
4125
4126 #[inline]
4127 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4128 ::fidl_next::munge! {
4129 let Self {
4130 exposed_dir,
4131
4132 } = &mut *out_;
4133 }
4134
4135 ::fidl_next::Wire::zero_padding(exposed_dir);
4136 }
4137 }
4138
4139 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerOpenExposedDirRequest
4140 where
4141 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4142 ___D: ::fidl_next::fuchsia::HandleDecoder,
4143 {
4144 fn decode(
4145 slot_: ::fidl_next::Slot<'_, Self>,
4146 decoder_: &mut ___D,
4147 _: (),
4148 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4149 ::fidl_next::munge! {
4150 let Self {
4151 mut exposed_dir,
4152
4153 } = slot_;
4154 }
4155
4156 let _field = exposed_dir.as_mut();
4157
4158 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
4159
4160 Ok(())
4161 }
4162 }
4163
4164 impl ::fidl_next::IntoNatural for ControllerOpenExposedDirRequest {
4165 type Natural = crate::natural::ControllerOpenExposedDirRequest;
4166 }
4167
4168 #[repr(C)]
4170 pub struct CreateChildArgs<'de> {
4171 pub(crate) table: ::fidl_next::wire::Table<'de>,
4172 }
4173
4174 impl<'de> Drop for CreateChildArgs<'de> {
4175 fn drop(&mut self) {
4176 let _ = self.table.get(1).map(|envelope| unsafe {
4177 envelope.read_unchecked::<::fidl_next::wire::Vector<
4178 'de,
4179 ::fidl_next_fuchsia_process::wire::HandleInfo,
4180 >>()
4181 });
4182
4183 let _ = self.table.get(2).map(|envelope| unsafe {
4184 envelope.read_unchecked::<::fidl_next::wire::Vector<
4185 'de,
4186 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4187 >>()
4188 });
4189
4190 let _ = self.table.get(3).map(|envelope| unsafe {
4191 envelope.read_unchecked::<::fidl_next::ServerEnd<
4192 crate::Controller,
4193 ::fidl_next::wire::fuchsia::Channel,
4194 >>()
4195 });
4196
4197 let _ = self.table.get(4)
4198 .map(|envelope| unsafe {
4199 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
4200 });
4201
4202 let _ = self.table.get(5).map(|envelope| unsafe {
4203 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4204 });
4205 }
4206 }
4207
4208 impl ::fidl_next::Constrained for CreateChildArgs<'_> {
4209 type Constraint = ();
4210
4211 fn validate(
4212 _: ::fidl_next::Slot<'_, Self>,
4213 _: Self::Constraint,
4214 ) -> Result<(), ::fidl_next::ValidationError> {
4215 Ok(())
4216 }
4217 }
4218
4219 unsafe impl ::fidl_next::Wire for CreateChildArgs<'static> {
4220 type Narrowed<'de> = CreateChildArgs<'de>;
4221
4222 #[inline]
4223 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4224 ::fidl_next::munge!(let Self { table } = out);
4225 ::fidl_next::wire::Table::zero_padding(table);
4226 }
4227 }
4228
4229 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateChildArgs<'de>
4230 where
4231 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4232 ___D: ::fidl_next::fuchsia::HandleDecoder,
4233 {
4234 fn decode(
4235 slot: ::fidl_next::Slot<'_, Self>,
4236 decoder: &mut ___D,
4237 _: (),
4238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4239 ::fidl_next::munge!(let Self { table } = slot);
4240
4241 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4242 match ordinal {
4243 0 => unsafe { ::core::hint::unreachable_unchecked() },
4244
4245 1 => {
4246 ::fidl_next::wire::Envelope::decode_as::<
4247 ___D,
4248 ::fidl_next::wire::Vector<
4249 'de,
4250 ::fidl_next_fuchsia_process::wire::HandleInfo,
4251 >,
4252 >(slot.as_mut(), decoder, (128, ()))?;
4253
4254 let value = unsafe {
4255 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4256 '_,
4257 ::fidl_next_fuchsia_process::wire::HandleInfo,
4258 >>()
4259 };
4260
4261 if value.len() > 128 {
4262 return Err(::fidl_next::DecodeError::VectorTooLong {
4263 size: value.len() as u64,
4264 limit: 128,
4265 });
4266 }
4267
4268 Ok(())
4269 }
4270
4271 2 => {
4272 ::fidl_next::wire::Envelope::decode_as::<
4273 ___D,
4274 ::fidl_next::wire::Vector<
4275 'de,
4276 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4277 >,
4278 >(slot.as_mut(), decoder, (128, ()))?;
4279
4280 let value = unsafe {
4281 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4282 '_,
4283 ::fidl_next_fuchsia_component_decl::wire::Offer<'_>,
4284 >>()
4285 };
4286
4287 if value.len() > 128 {
4288 return Err(::fidl_next::DecodeError::VectorTooLong {
4289 size: value.len() as u64,
4290 limit: 128,
4291 });
4292 }
4293
4294 Ok(())
4295 }
4296
4297 3 => {
4298 ::fidl_next::wire::Envelope::decode_as::<
4299 ___D,
4300 ::fidl_next::ServerEnd<
4301 crate::Controller,
4302 ::fidl_next::wire::fuchsia::Channel,
4303 >,
4304 >(slot.as_mut(), decoder, ())?;
4305
4306 Ok(())
4307 }
4308
4309 4 => {
4310 ::fidl_next::wire::Envelope::decode_as::<
4311 ___D,
4312 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
4313 >(slot.as_mut(), decoder, ())?;
4314
4315 Ok(())
4316 }
4317
4318 5 => {
4319 ::fidl_next::wire::Envelope::decode_as::<
4320 ___D,
4321 ::fidl_next::wire::fuchsia::EventPair,
4322 >(slot.as_mut(), decoder, ())?;
4323
4324 Ok(())
4325 }
4326
4327 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4328 }
4329 })
4330 }
4331 }
4332
4333 impl<'de> CreateChildArgs<'de> {
4334 pub fn numbered_handles(
4335 &self,
4336 ) -> ::core::option::Option<
4337 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4338 > {
4339 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4340 }
4341
4342 pub fn take_numbered_handles(
4343 &mut self,
4344 ) -> ::core::option::Option<
4345 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4346 > {
4347 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4348 }
4349
4350 pub fn dynamic_offers(
4351 &self,
4352 ) -> ::core::option::Option<
4353 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4354 > {
4355 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4356 }
4357
4358 pub fn take_dynamic_offers(
4359 &mut self,
4360 ) -> ::core::option::Option<
4361 ::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4362 > {
4363 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4364 }
4365
4366 pub fn controller(
4367 &self,
4368 ) -> ::core::option::Option<
4369 &::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4370 > {
4371 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4372 }
4373
4374 pub fn take_controller(
4375 &mut self,
4376 ) -> ::core::option::Option<
4377 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4378 > {
4379 unsafe { Some(self.table.get_mut(3)?.take_unchecked()) }
4380 }
4381
4382 pub fn dictionary(
4383 &self,
4384 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4385 {
4386 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4387 }
4388
4389 pub fn take_dictionary(
4390 &mut self,
4391 ) -> ::core::option::Option<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4392 {
4393 unsafe { Some(self.table.get_mut(4)?.take_unchecked()) }
4394 }
4395
4396 pub fn additional_inputs(
4397 &self,
4398 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4399 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
4400 }
4401
4402 pub fn take_additional_inputs(
4403 &mut self,
4404 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
4405 unsafe { Some(self.table.get_mut(5)?.take_unchecked()) }
4406 }
4407 }
4408
4409 impl<'de> ::core::fmt::Debug for CreateChildArgs<'de> {
4410 fn fmt(
4411 &self,
4412 f: &mut ::core::fmt::Formatter<'_>,
4413 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4414 f.debug_struct("CreateChildArgs")
4415 .field("numbered_handles", &self.numbered_handles())
4416 .field("dynamic_offers", &self.dynamic_offers())
4417 .field("controller", &self.controller())
4418 .field("dictionary", &self.dictionary())
4419 .field("additional_inputs", &self.additional_inputs())
4420 .finish()
4421 }
4422 }
4423
4424 impl<'de> ::fidl_next::IntoNatural for CreateChildArgs<'de> {
4425 type Natural = crate::natural::CreateChildArgs;
4426 }
4427
4428 #[repr(C)]
4430 pub struct DebugStartedPayload<'de> {
4431 pub(crate) table: ::fidl_next::wire::Table<'de>,
4432 }
4433
4434 impl<'de> Drop for DebugStartedPayload<'de> {
4435 fn drop(&mut self) {
4436 let _ = self.table.get(1).map(|envelope| unsafe {
4437 envelope.read_unchecked::<::fidl_next::ClientEnd<
4438 ::fidl_next_fuchsia_io::Directory,
4439 ::fidl_next::wire::fuchsia::Channel,
4440 >>()
4441 });
4442
4443 let _ = self.table.get(2).map(|envelope| unsafe {
4444 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4445 });
4446 }
4447 }
4448
4449 impl ::fidl_next::Constrained for DebugStartedPayload<'_> {
4450 type Constraint = ();
4451
4452 fn validate(
4453 _: ::fidl_next::Slot<'_, Self>,
4454 _: Self::Constraint,
4455 ) -> Result<(), ::fidl_next::ValidationError> {
4456 Ok(())
4457 }
4458 }
4459
4460 unsafe impl ::fidl_next::Wire for DebugStartedPayload<'static> {
4461 type Narrowed<'de> = DebugStartedPayload<'de>;
4462
4463 #[inline]
4464 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4465 ::fidl_next::munge!(let Self { table } = out);
4466 ::fidl_next::wire::Table::zero_padding(table);
4467 }
4468 }
4469
4470 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugStartedPayload<'de>
4471 where
4472 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4473 ___D: ::fidl_next::fuchsia::HandleDecoder,
4474 {
4475 fn decode(
4476 slot: ::fidl_next::Slot<'_, Self>,
4477 decoder: &mut ___D,
4478 _: (),
4479 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4480 ::fidl_next::munge!(let Self { table } = slot);
4481
4482 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4483 match ordinal {
4484 0 => unsafe { ::core::hint::unreachable_unchecked() },
4485
4486 1 => {
4487 ::fidl_next::wire::Envelope::decode_as::<
4488 ___D,
4489 ::fidl_next::ClientEnd<
4490 ::fidl_next_fuchsia_io::Directory,
4491 ::fidl_next::wire::fuchsia::Channel,
4492 >,
4493 >(slot.as_mut(), decoder, ())?;
4494
4495 Ok(())
4496 }
4497
4498 2 => {
4499 ::fidl_next::wire::Envelope::decode_as::<
4500 ___D,
4501 ::fidl_next::wire::fuchsia::EventPair,
4502 >(slot.as_mut(), decoder, ())?;
4503
4504 Ok(())
4505 }
4506
4507 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4508 }
4509 })
4510 }
4511 }
4512
4513 impl<'de> DebugStartedPayload<'de> {
4514 pub fn runtime_dir(
4515 &self,
4516 ) -> ::core::option::Option<
4517 &::fidl_next::ClientEnd<
4518 ::fidl_next_fuchsia_io::Directory,
4519 ::fidl_next::wire::fuchsia::Channel,
4520 >,
4521 > {
4522 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4523 }
4524
4525 pub fn take_runtime_dir(
4526 &mut self,
4527 ) -> ::core::option::Option<
4528 ::fidl_next::ClientEnd<
4529 ::fidl_next_fuchsia_io::Directory,
4530 ::fidl_next::wire::fuchsia::Channel,
4531 >,
4532 > {
4533 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4534 }
4535
4536 pub fn break_on_start(
4537 &self,
4538 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4539 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4540 }
4541
4542 pub fn take_break_on_start(
4543 &mut self,
4544 ) -> ::core::option::Option<::fidl_next::wire::fuchsia::EventPair> {
4545 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
4546 }
4547 }
4548
4549 impl<'de> ::core::fmt::Debug for DebugStartedPayload<'de> {
4550 fn fmt(
4551 &self,
4552 f: &mut ::core::fmt::Formatter<'_>,
4553 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4554 f.debug_struct("DebugStartedPayload")
4555 .field("runtime_dir", &self.runtime_dir())
4556 .field("break_on_start", &self.break_on_start())
4557 .finish()
4558 }
4559 }
4560
4561 impl<'de> ::fidl_next::IntoNatural for DebugStartedPayload<'de> {
4562 type Natural = crate::natural::DebugStartedPayload;
4563 }
4564
4565 #[repr(transparent)]
4567 pub struct EventPayload<'de> {
4568 pub(crate) raw: ::fidl_next::wire::Union,
4569 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4570 }
4571
4572 impl<'de> Drop for EventPayload<'de> {
4573 fn drop(&mut self) {
4574 match self.raw.ordinal() {
4575 1 => {
4576 let _ = unsafe {
4577 self.raw
4578 .get()
4579 .read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4580 };
4581 }
4582
4583 2 => {
4584 let _ = unsafe {
4585 self.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4586 };
4587 }
4588
4589 4 => {
4590 let _ = unsafe {
4591 self.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4592 };
4593 }
4594
4595 5 => {
4596 let _ = unsafe {
4597 self.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4598 };
4599 }
4600
4601 6 => {
4602 let _ = unsafe {
4603 self.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4604 };
4605 }
4606
4607 7 => {
4608 let _ = unsafe {
4609 self.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4610 };
4611 }
4612
4613 8 => {
4614 let _ = unsafe {
4615 self.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4616 };
4617 }
4618
4619 9 => {
4620 let _ = unsafe {
4621 self.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4622 };
4623 }
4624
4625 10 => {
4626 let _ = unsafe {
4627 self.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4628 };
4629 }
4630
4631 _ => (),
4632 }
4633 }
4634 }
4635
4636 impl ::fidl_next::Constrained for EventPayload<'_> {
4637 type Constraint = ();
4638
4639 fn validate(
4640 _: ::fidl_next::Slot<'_, Self>,
4641 _: Self::Constraint,
4642 ) -> Result<(), ::fidl_next::ValidationError> {
4643 Ok(())
4644 }
4645 }
4646
4647 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
4648 type Narrowed<'de> = EventPayload<'de>;
4649
4650 #[inline]
4651 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4652 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4653 ::fidl_next::wire::Union::zero_padding(raw);
4654 }
4655 }
4656
4657 pub mod event_payload {
4658 pub enum Ref<'de> {
4659 CapabilityRequested(&'de crate::wire::CapabilityRequestedPayload<'de>),
4660
4661 Purged(&'de crate::wire::PurgedPayload<'de>),
4662
4663 Discovered(&'de crate::wire::DiscoveredPayload<'de>),
4664
4665 Destroyed(&'de crate::wire::DestroyedPayload<'de>),
4666
4667 Resolved(&'de crate::wire::ResolvedPayload<'de>),
4668
4669 Started(&'de crate::wire::StartedPayload<'de>),
4670
4671 Stopped(&'de crate::wire::StoppedPayload<'de>),
4672
4673 DebugStarted(&'de crate::wire::DebugStartedPayload<'de>),
4674
4675 Unresolved(&'de crate::wire::UnresolvedPayload<'de>),
4676
4677 UnknownOrdinal_(u64),
4678 }
4679
4680 pub enum Value<'de> {
4681 CapabilityRequested(crate::wire::CapabilityRequestedPayload<'de>),
4682
4683 Purged(crate::wire::PurgedPayload<'de>),
4684
4685 Discovered(crate::wire::DiscoveredPayload<'de>),
4686
4687 Destroyed(crate::wire::DestroyedPayload<'de>),
4688
4689 Resolved(crate::wire::ResolvedPayload<'de>),
4690
4691 Started(crate::wire::StartedPayload<'de>),
4692
4693 Stopped(crate::wire::StoppedPayload<'de>),
4694
4695 DebugStarted(crate::wire::DebugStartedPayload<'de>),
4696
4697 Unresolved(crate::wire::UnresolvedPayload<'de>),
4698
4699 UnknownOrdinal_(u64),
4700 }
4701 }
4702
4703 impl<'de> EventPayload<'de> {
4704 pub fn as_ref(&self) -> crate::wire::event_payload::Ref<'_> {
4705 match self.raw.ordinal() {
4706 1 => crate::wire::event_payload::Ref::CapabilityRequested(unsafe {
4707 self.raw.get().deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4708 }),
4709
4710 2 => crate::wire::event_payload::Ref::Purged(unsafe {
4711 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>()
4712 }),
4713
4714 4 => crate::wire::event_payload::Ref::Discovered(unsafe {
4715 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>()
4716 }),
4717
4718 5 => crate::wire::event_payload::Ref::Destroyed(unsafe {
4719 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>()
4720 }),
4721
4722 6 => crate::wire::event_payload::Ref::Resolved(unsafe {
4723 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>()
4724 }),
4725
4726 7 => crate::wire::event_payload::Ref::Started(unsafe {
4727 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>()
4728 }),
4729
4730 8 => crate::wire::event_payload::Ref::Stopped(unsafe {
4731 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>()
4732 }),
4733
4734 9 => crate::wire::event_payload::Ref::DebugStarted(unsafe {
4735 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>()
4736 }),
4737
4738 10 => crate::wire::event_payload::Ref::Unresolved(unsafe {
4739 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>()
4740 }),
4741
4742 unknown => crate::wire::event_payload::Ref::UnknownOrdinal_(unknown),
4743 }
4744 }
4745
4746 pub fn into_inner(self) -> crate::wire::event_payload::Value<'de> {
4747 let this = ::core::mem::ManuallyDrop::new(self);
4748
4749 match this.raw.ordinal() {
4750 1 => crate::wire::event_payload::Value::CapabilityRequested(unsafe {
4751 this.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4752 }),
4753
4754 2 => crate::wire::event_payload::Value::Purged(unsafe {
4755 this.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4756 }),
4757
4758 4 => crate::wire::event_payload::Value::Discovered(unsafe {
4759 this.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4760 }),
4761
4762 5 => crate::wire::event_payload::Value::Destroyed(unsafe {
4763 this.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4764 }),
4765
4766 6 => crate::wire::event_payload::Value::Resolved(unsafe {
4767 this.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4768 }),
4769
4770 7 => crate::wire::event_payload::Value::Started(unsafe {
4771 this.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4772 }),
4773
4774 8 => crate::wire::event_payload::Value::Stopped(unsafe {
4775 this.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4776 }),
4777
4778 9 => crate::wire::event_payload::Value::DebugStarted(unsafe {
4779 this.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4780 }),
4781
4782 10 => crate::wire::event_payload::Value::Unresolved(unsafe {
4783 this.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4784 }),
4785
4786 unknown => crate::wire::event_payload::Value::UnknownOrdinal_(unknown),
4787 }
4788 }
4789 }
4790
4791 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
4792 where
4793 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4794 ___D: ::fidl_next::Decoder<'de>,
4795 ___D: ::fidl_next::fuchsia::HandleDecoder,
4796 {
4797 fn decode(
4798 mut slot: ::fidl_next::Slot<'_, Self>,
4799 decoder: &mut ___D,
4800 _: (),
4801 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4802 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4803 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4804 1 => ::fidl_next::wire::Union::decode_as::<
4805 ___D,
4806 crate::wire::CapabilityRequestedPayload<'de>,
4807 >(raw, decoder, ())?,
4808
4809 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
4810 raw,
4811 decoder,
4812 (),
4813 )?,
4814
4815 4 => ::fidl_next::wire::Union::decode_as::<
4816 ___D,
4817 crate::wire::DiscoveredPayload<'de>,
4818 >(raw, decoder, ())?,
4819
4820 5 => {
4821 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
4822 raw,
4823 decoder,
4824 (),
4825 )?
4826 }
4827
4828 6 => {
4829 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
4830 raw,
4831 decoder,
4832 (),
4833 )?
4834 }
4835
4836 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
4837 raw,
4838 decoder,
4839 (),
4840 )?,
4841
4842 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
4843 raw,
4844 decoder,
4845 (),
4846 )?,
4847
4848 9 => ::fidl_next::wire::Union::decode_as::<
4849 ___D,
4850 crate::wire::DebugStartedPayload<'de>,
4851 >(raw, decoder, ())?,
4852
4853 10 => ::fidl_next::wire::Union::decode_as::<
4854 ___D,
4855 crate::wire::UnresolvedPayload<'de>,
4856 >(raw, decoder, ())?,
4857
4858 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4859 }
4860
4861 Ok(())
4862 }
4863 }
4864
4865 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
4866 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4867 match self.raw.ordinal() {
4868 1 => unsafe {
4869 self.raw
4870 .get()
4871 .deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4872 .fmt(f)
4873 },
4874 2 => unsafe {
4875 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>().fmt(f)
4876 },
4877 4 => unsafe {
4878 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>().fmt(f)
4879 },
4880 5 => unsafe {
4881 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>().fmt(f)
4882 },
4883 6 => unsafe {
4884 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>().fmt(f)
4885 },
4886 7 => unsafe {
4887 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>().fmt(f)
4888 },
4889 8 => unsafe {
4890 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>().fmt(f)
4891 },
4892 9 => unsafe {
4893 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>().fmt(f)
4894 },
4895 10 => unsafe {
4896 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>().fmt(f)
4897 },
4898 _ => unsafe { ::core::hint::unreachable_unchecked() },
4899 }
4900 }
4901 }
4902
4903 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
4904 type Natural = crate::natural::EventPayload;
4905 }
4906
4907 #[repr(C)]
4909 pub struct Event<'de> {
4910 pub(crate) table: ::fidl_next::wire::Table<'de>,
4911 }
4912
4913 impl<'de> Drop for Event<'de> {
4914 fn drop(&mut self) {
4915 let _ = self.table.get(1).map(|envelope| unsafe {
4916 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
4917 });
4918
4919 let _ = self.table.get(2).map(|envelope| unsafe {
4920 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
4921 });
4922 }
4923 }
4924
4925 impl ::fidl_next::Constrained for Event<'_> {
4926 type Constraint = ();
4927
4928 fn validate(
4929 _: ::fidl_next::Slot<'_, Self>,
4930 _: Self::Constraint,
4931 ) -> Result<(), ::fidl_next::ValidationError> {
4932 Ok(())
4933 }
4934 }
4935
4936 unsafe impl ::fidl_next::Wire for Event<'static> {
4937 type Narrowed<'de> = Event<'de>;
4938
4939 #[inline]
4940 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4941 ::fidl_next::munge!(let Self { table } = out);
4942 ::fidl_next::wire::Table::zero_padding(table);
4943 }
4944 }
4945
4946 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Event<'de>
4947 where
4948 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4949 ___D: ::fidl_next::fuchsia::HandleDecoder,
4950 {
4951 fn decode(
4952 slot: ::fidl_next::Slot<'_, Self>,
4953 decoder: &mut ___D,
4954 _: (),
4955 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4956 ::fidl_next::munge!(let Self { table } = slot);
4957
4958 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4959 match ordinal {
4960 0 => unsafe { ::core::hint::unreachable_unchecked() },
4961
4962 1 => {
4963 ::fidl_next::wire::Envelope::decode_as::<
4964 ___D,
4965 crate::wire::EventHeader<'de>,
4966 >(slot.as_mut(), decoder, ())?;
4967
4968 Ok(())
4969 }
4970
4971 2 => {
4972 ::fidl_next::wire::Envelope::decode_as::<
4973 ___D,
4974 crate::wire::EventPayload<'de>,
4975 >(slot.as_mut(), decoder, ())?;
4976
4977 Ok(())
4978 }
4979
4980 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4981 }
4982 })
4983 }
4984 }
4985
4986 impl<'de> Event<'de> {
4987 pub fn header(&self) -> ::core::option::Option<&crate::wire::EventHeader<'de>> {
4988 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4989 }
4990
4991 pub fn take_header(&mut self) -> ::core::option::Option<crate::wire::EventHeader<'de>> {
4992 unsafe { Some(self.table.get_mut(1)?.take_unchecked()) }
4993 }
4994
4995 pub fn payload(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
4996 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4997 }
4998
4999 pub fn take_payload(&mut self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
5000 unsafe { Some(self.table.get_mut(2)?.take_unchecked()) }
5001 }
5002 }
5003
5004 impl<'de> ::core::fmt::Debug for Event<'de> {
5005 fn fmt(
5006 &self,
5007 f: &mut ::core::fmt::Formatter<'_>,
5008 ) -> ::core::result::Result<(), ::core::fmt::Error> {
5009 f.debug_struct("Event")
5010 .field("header", &self.header())
5011 .field("payload", &self.payload())
5012 .finish()
5013 }
5014 }
5015
5016 impl<'de> ::fidl_next::IntoNatural for Event<'de> {
5017 type Natural = crate::natural::Event;
5018 }
5019
5020 #[derive(Debug)]
5022 #[repr(C)]
5023 pub struct EventStreamGetNextResponse<'de> {
5024 pub events: ::fidl_next::wire::Vector<'de, crate::wire::Event<'de>>,
5025 }
5026
5027 static_assertions::const_assert_eq!(std::mem::size_of::<EventStreamGetNextResponse<'_>>(), 16);
5028 static_assertions::const_assert_eq!(std::mem::align_of::<EventStreamGetNextResponse<'_>>(), 8);
5029
5030 static_assertions::const_assert_eq!(
5031 std::mem::offset_of!(EventStreamGetNextResponse<'_>, events),
5032 0
5033 );
5034
5035 impl ::fidl_next::Constrained for EventStreamGetNextResponse<'_> {
5036 type Constraint = ();
5037
5038 fn validate(
5039 _: ::fidl_next::Slot<'_, Self>,
5040 _: Self::Constraint,
5041 ) -> Result<(), ::fidl_next::ValidationError> {
5042 Ok(())
5043 }
5044 }
5045
5046 unsafe impl ::fidl_next::Wire for EventStreamGetNextResponse<'static> {
5047 type Narrowed<'de> = EventStreamGetNextResponse<'de>;
5048
5049 #[inline]
5050 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5051 ::fidl_next::munge! {
5052 let Self {
5053 events,
5054
5055 } = &mut *out_;
5056 }
5057
5058 ::fidl_next::Wire::zero_padding(events);
5059 }
5060 }
5061
5062 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStreamGetNextResponse<'de>
5063 where
5064 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5065 ___D: ::fidl_next::Decoder<'de>,
5066 ___D: ::fidl_next::fuchsia::HandleDecoder,
5067 {
5068 fn decode(
5069 slot_: ::fidl_next::Slot<'_, Self>,
5070 decoder_: &mut ___D,
5071 _: (),
5072 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5073 ::fidl_next::munge! {
5074 let Self {
5075 mut events,
5076
5077 } = slot_;
5078 }
5079
5080 let _field = events.as_mut();
5081 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5082 ::fidl_next::Decode::decode(events.as_mut(), decoder_, (4294967295, ()))?;
5083
5084 Ok(())
5085 }
5086 }
5087
5088 impl<'de> ::fidl_next::IntoNatural for EventStreamGetNextResponse<'de> {
5089 type Natural = crate::natural::EventStreamGetNextResponse;
5090 }
5091
5092 #[derive(Debug)]
5094 #[repr(C)]
5095 pub struct IntrospectorGetMonikerRequest {
5096 pub component_instance: ::fidl_next::wire::fuchsia::Event,
5097 }
5098
5099 static_assertions::const_assert_eq!(std::mem::size_of::<IntrospectorGetMonikerRequest>(), 4);
5100 static_assertions::const_assert_eq!(std::mem::align_of::<IntrospectorGetMonikerRequest>(), 4);
5101
5102 static_assertions::const_assert_eq!(
5103 std::mem::offset_of!(IntrospectorGetMonikerRequest, component_instance),
5104 0
5105 );
5106
5107 impl ::fidl_next::Constrained for IntrospectorGetMonikerRequest {
5108 type Constraint = ();
5109
5110 fn validate(
5111 _: ::fidl_next::Slot<'_, Self>,
5112 _: Self::Constraint,
5113 ) -> Result<(), ::fidl_next::ValidationError> {
5114 Ok(())
5115 }
5116 }
5117
5118 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerRequest {
5119 type Narrowed<'de> = IntrospectorGetMonikerRequest;
5120
5121 #[inline]
5122 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5123 ::fidl_next::munge! {
5124 let Self {
5125 component_instance,
5126
5127 } = &mut *out_;
5128 }
5129
5130 ::fidl_next::Wire::zero_padding(component_instance);
5131 }
5132 }
5133
5134 unsafe impl<___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerRequest
5135 where
5136 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5137 ___D: ::fidl_next::fuchsia::HandleDecoder,
5138 {
5139 fn decode(
5140 slot_: ::fidl_next::Slot<'_, Self>,
5141 decoder_: &mut ___D,
5142 _: (),
5143 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5144 ::fidl_next::munge! {
5145 let Self {
5146 mut component_instance,
5147
5148 } = slot_;
5149 }
5150
5151 let _field = component_instance.as_mut();
5152
5153 ::fidl_next::Decode::decode(component_instance.as_mut(), decoder_, ())?;
5154
5155 Ok(())
5156 }
5157 }
5158
5159 impl ::fidl_next::IntoNatural for IntrospectorGetMonikerRequest {
5160 type Natural = crate::natural::IntrospectorGetMonikerRequest;
5161 }
5162
5163 #[derive(Debug)]
5165 #[repr(C)]
5166 pub struct NamespaceInputEntry<'de> {
5167 pub path: ::fidl_next::wire::String<'de>,
5168
5169 pub dictionary: ::fidl_next::ClientEnd<
5170 ::fidl_next_fuchsia_component_sandbox::Dictionary,
5171 ::fidl_next::wire::fuchsia::Channel,
5172 >,
5173 }
5174
5175 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry<'_>>(), 24);
5176 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry<'_>>(), 8);
5177
5178 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry<'_>, path), 0);
5179
5180 static_assertions::const_assert_eq!(
5181 std::mem::offset_of!(NamespaceInputEntry<'_>, dictionary),
5182 16
5183 );
5184
5185 impl ::fidl_next::Constrained for NamespaceInputEntry<'_> {
5186 type Constraint = ();
5187
5188 fn validate(
5189 _: ::fidl_next::Slot<'_, Self>,
5190 _: Self::Constraint,
5191 ) -> Result<(), ::fidl_next::ValidationError> {
5192 Ok(())
5193 }
5194 }
5195
5196 unsafe impl ::fidl_next::Wire for NamespaceInputEntry<'static> {
5197 type Narrowed<'de> = NamespaceInputEntry<'de>;
5198
5199 #[inline]
5200 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5201 ::fidl_next::munge! {
5202 let Self {
5203 path,
5204 dictionary,
5205
5206 } = &mut *out_;
5207 }
5208
5209 ::fidl_next::Wire::zero_padding(path);
5210
5211 ::fidl_next::Wire::zero_padding(dictionary);
5212
5213 unsafe {
5214 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5215 }
5216 }
5217 }
5218
5219 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry<'de>
5220 where
5221 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5222 ___D: ::fidl_next::Decoder<'de>,
5223 ___D: ::fidl_next::fuchsia::HandleDecoder,
5224 {
5225 fn decode(
5226 slot_: ::fidl_next::Slot<'_, Self>,
5227 decoder_: &mut ___D,
5228 _: (),
5229 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5230 if slot_.as_bytes()[20..24] != [0u8; 4] {
5231 return Err(::fidl_next::DecodeError::InvalidPadding);
5232 }
5233
5234 ::fidl_next::munge! {
5235 let Self {
5236 mut path,
5237 mut dictionary,
5238
5239 } = slot_;
5240 }
5241
5242 let _field = path.as_mut();
5243 ::fidl_next::Constrained::validate(_field, 4095)?;
5244 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5245
5246 let path = unsafe { path.deref_unchecked() };
5247
5248 if path.len() > 4095 {
5249 return Err(::fidl_next::DecodeError::VectorTooLong {
5250 size: path.len() as u64,
5251 limit: 4095,
5252 });
5253 }
5254
5255 let _field = dictionary.as_mut();
5256
5257 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5258
5259 Ok(())
5260 }
5261 }
5262
5263 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry<'de> {
5264 type Natural = crate::natural::NamespaceInputEntry;
5265 }
5266
5267 #[derive(Debug)]
5269 #[repr(C)]
5270 pub struct NamespaceCreateRequest<'de> {
5271 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry<'de>>,
5272 }
5273
5274 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateRequest<'_>>(), 16);
5275 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateRequest<'_>>(), 8);
5276
5277 static_assertions::const_assert_eq!(
5278 std::mem::offset_of!(NamespaceCreateRequest<'_>, entries),
5279 0
5280 );
5281
5282 impl ::fidl_next::Constrained for NamespaceCreateRequest<'_> {
5283 type Constraint = ();
5284
5285 fn validate(
5286 _: ::fidl_next::Slot<'_, Self>,
5287 _: Self::Constraint,
5288 ) -> Result<(), ::fidl_next::ValidationError> {
5289 Ok(())
5290 }
5291 }
5292
5293 unsafe impl ::fidl_next::Wire for NamespaceCreateRequest<'static> {
5294 type Narrowed<'de> = NamespaceCreateRequest<'de>;
5295
5296 #[inline]
5297 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5298 ::fidl_next::munge! {
5299 let Self {
5300 entries,
5301
5302 } = &mut *out_;
5303 }
5304
5305 ::fidl_next::Wire::zero_padding(entries);
5306 }
5307 }
5308
5309 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateRequest<'de>
5310 where
5311 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5312 ___D: ::fidl_next::Decoder<'de>,
5313 ___D: ::fidl_next::fuchsia::HandleDecoder,
5314 {
5315 fn decode(
5316 slot_: ::fidl_next::Slot<'_, Self>,
5317 decoder_: &mut ___D,
5318 _: (),
5319 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5320 ::fidl_next::munge! {
5321 let Self {
5322 mut entries,
5323
5324 } = slot_;
5325 }
5326
5327 let _field = entries.as_mut();
5328 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5329 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5330
5331 Ok(())
5332 }
5333 }
5334
5335 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateRequest<'de> {
5336 type Natural = crate::natural::NamespaceCreateRequest;
5337 }
5338
5339 #[derive(Debug)]
5341 #[repr(C)]
5342 pub struct NamespaceInputEntry2<'de> {
5343 pub path: ::fidl_next::wire::String<'de>,
5344
5345 pub capability: ::fidl_next::wire::fuchsia::EventPair,
5346 }
5347
5348 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry2<'_>>(), 24);
5349 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry2<'_>>(), 8);
5350
5351 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry2<'_>, path), 0);
5352
5353 static_assertions::const_assert_eq!(
5354 std::mem::offset_of!(NamespaceInputEntry2<'_>, capability),
5355 16
5356 );
5357
5358 impl ::fidl_next::Constrained for NamespaceInputEntry2<'_> {
5359 type Constraint = ();
5360
5361 fn validate(
5362 _: ::fidl_next::Slot<'_, Self>,
5363 _: Self::Constraint,
5364 ) -> Result<(), ::fidl_next::ValidationError> {
5365 Ok(())
5366 }
5367 }
5368
5369 unsafe impl ::fidl_next::Wire for NamespaceInputEntry2<'static> {
5370 type Narrowed<'de> = NamespaceInputEntry2<'de>;
5371
5372 #[inline]
5373 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5374 ::fidl_next::munge! {
5375 let Self {
5376 path,
5377 capability,
5378
5379 } = &mut *out_;
5380 }
5381
5382 ::fidl_next::Wire::zero_padding(path);
5383
5384 ::fidl_next::Wire::zero_padding(capability);
5385
5386 unsafe {
5387 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5388 }
5389 }
5390 }
5391
5392 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry2<'de>
5393 where
5394 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5395 ___D: ::fidl_next::Decoder<'de>,
5396 ___D: ::fidl_next::fuchsia::HandleDecoder,
5397 {
5398 fn decode(
5399 slot_: ::fidl_next::Slot<'_, Self>,
5400 decoder_: &mut ___D,
5401 _: (),
5402 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5403 if slot_.as_bytes()[20..24] != [0u8; 4] {
5404 return Err(::fidl_next::DecodeError::InvalidPadding);
5405 }
5406
5407 ::fidl_next::munge! {
5408 let Self {
5409 mut path,
5410 mut capability,
5411
5412 } = slot_;
5413 }
5414
5415 let _field = path.as_mut();
5416 ::fidl_next::Constrained::validate(_field, 4095)?;
5417 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5418
5419 let path = unsafe { path.deref_unchecked() };
5420
5421 if path.len() > 4095 {
5422 return Err(::fidl_next::DecodeError::VectorTooLong {
5423 size: path.len() as u64,
5424 limit: 4095,
5425 });
5426 }
5427
5428 let _field = capability.as_mut();
5429
5430 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5431
5432 Ok(())
5433 }
5434 }
5435
5436 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry2<'de> {
5437 type Natural = crate::natural::NamespaceInputEntry2;
5438 }
5439
5440 #[derive(Debug)]
5442 #[repr(C)]
5443 pub struct NamespaceCreate2Request<'de> {
5444 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry2<'de>>,
5445 }
5446
5447 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Request<'_>>(), 16);
5448 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Request<'_>>(), 8);
5449
5450 static_assertions::const_assert_eq!(
5451 std::mem::offset_of!(NamespaceCreate2Request<'_>, entries),
5452 0
5453 );
5454
5455 impl ::fidl_next::Constrained for NamespaceCreate2Request<'_> {
5456 type Constraint = ();
5457
5458 fn validate(
5459 _: ::fidl_next::Slot<'_, Self>,
5460 _: Self::Constraint,
5461 ) -> Result<(), ::fidl_next::ValidationError> {
5462 Ok(())
5463 }
5464 }
5465
5466 unsafe impl ::fidl_next::Wire for NamespaceCreate2Request<'static> {
5467 type Narrowed<'de> = NamespaceCreate2Request<'de>;
5468
5469 #[inline]
5470 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5471 ::fidl_next::munge! {
5472 let Self {
5473 entries,
5474
5475 } = &mut *out_;
5476 }
5477
5478 ::fidl_next::Wire::zero_padding(entries);
5479 }
5480 }
5481
5482 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Request<'de>
5483 where
5484 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5485 ___D: ::fidl_next::Decoder<'de>,
5486 ___D: ::fidl_next::fuchsia::HandleDecoder,
5487 {
5488 fn decode(
5489 slot_: ::fidl_next::Slot<'_, Self>,
5490 decoder_: &mut ___D,
5491 _: (),
5492 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5493 ::fidl_next::munge! {
5494 let Self {
5495 mut entries,
5496
5497 } = slot_;
5498 }
5499
5500 let _field = entries.as_mut();
5501 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5502 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5503
5504 Ok(())
5505 }
5506 }
5507
5508 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Request<'de> {
5509 type Natural = crate::natural::NamespaceCreate2Request;
5510 }
5511
5512 #[derive(Debug)]
5514 #[repr(C)]
5515 pub struct NamespaceCreateResponse<'de> {
5516 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5517 }
5518
5519 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateResponse<'_>>(), 16);
5520 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateResponse<'_>>(), 8);
5521
5522 static_assertions::const_assert_eq!(
5523 std::mem::offset_of!(NamespaceCreateResponse<'_>, entries),
5524 0
5525 );
5526
5527 impl ::fidl_next::Constrained for NamespaceCreateResponse<'_> {
5528 type Constraint = ();
5529
5530 fn validate(
5531 _: ::fidl_next::Slot<'_, Self>,
5532 _: Self::Constraint,
5533 ) -> Result<(), ::fidl_next::ValidationError> {
5534 Ok(())
5535 }
5536 }
5537
5538 unsafe impl ::fidl_next::Wire for NamespaceCreateResponse<'static> {
5539 type Narrowed<'de> = NamespaceCreateResponse<'de>;
5540
5541 #[inline]
5542 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5543 ::fidl_next::munge! {
5544 let Self {
5545 entries,
5546
5547 } = &mut *out_;
5548 }
5549
5550 ::fidl_next::Wire::zero_padding(entries);
5551 }
5552 }
5553
5554 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateResponse<'de>
5555 where
5556 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5557 ___D: ::fidl_next::Decoder<'de>,
5558 ___D: ::fidl_next::fuchsia::HandleDecoder,
5559 {
5560 fn decode(
5561 slot_: ::fidl_next::Slot<'_, Self>,
5562 decoder_: &mut ___D,
5563 _: (),
5564 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5565 ::fidl_next::munge! {
5566 let Self {
5567 mut entries,
5568
5569 } = slot_;
5570 }
5571
5572 let _field = entries.as_mut();
5573 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5574 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5575
5576 Ok(())
5577 }
5578 }
5579
5580 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateResponse<'de> {
5581 type Natural = crate::natural::NamespaceCreateResponse;
5582 }
5583
5584 #[derive(Debug)]
5586 #[repr(C)]
5587 pub struct NamespaceCreate2Response<'de> {
5588 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5589 }
5590
5591 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Response<'_>>(), 16);
5592 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Response<'_>>(), 8);
5593
5594 static_assertions::const_assert_eq!(
5595 std::mem::offset_of!(NamespaceCreate2Response<'_>, entries),
5596 0
5597 );
5598
5599 impl ::fidl_next::Constrained for NamespaceCreate2Response<'_> {
5600 type Constraint = ();
5601
5602 fn validate(
5603 _: ::fidl_next::Slot<'_, Self>,
5604 _: Self::Constraint,
5605 ) -> Result<(), ::fidl_next::ValidationError> {
5606 Ok(())
5607 }
5608 }
5609
5610 unsafe impl ::fidl_next::Wire for NamespaceCreate2Response<'static> {
5611 type Narrowed<'de> = NamespaceCreate2Response<'de>;
5612
5613 #[inline]
5614 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5615 ::fidl_next::munge! {
5616 let Self {
5617 entries,
5618
5619 } = &mut *out_;
5620 }
5621
5622 ::fidl_next::Wire::zero_padding(entries);
5623 }
5624 }
5625
5626 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Response<'de>
5627 where
5628 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5629 ___D: ::fidl_next::Decoder<'de>,
5630 ___D: ::fidl_next::fuchsia::HandleDecoder,
5631 {
5632 fn decode(
5633 slot_: ::fidl_next::Slot<'_, Self>,
5634 decoder_: &mut ___D,
5635 _: (),
5636 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5637 ::fidl_next::munge! {
5638 let Self {
5639 mut entries,
5640
5641 } = slot_;
5642 }
5643
5644 let _field = entries.as_mut();
5645 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5646 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5647
5648 Ok(())
5649 }
5650 }
5651
5652 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Response<'de> {
5653 type Natural = crate::natural::NamespaceCreate2Response;
5654 }
5655
5656 #[derive(Debug)]
5658 #[repr(C)]
5659 pub struct RealmListChildrenRequest<'de> {
5660 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
5661
5662 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
5663 }
5664
5665 static_assertions::const_assert_eq!(std::mem::size_of::<RealmListChildrenRequest<'_>>(), 24);
5666 static_assertions::const_assert_eq!(std::mem::align_of::<RealmListChildrenRequest<'_>>(), 8);
5667
5668 static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(RealmListChildrenRequest<'_>, collection),
5670 0
5671 );
5672
5673 static_assertions::const_assert_eq!(
5674 std::mem::offset_of!(RealmListChildrenRequest<'_>, iter),
5675 16
5676 );
5677
5678 impl ::fidl_next::Constrained for RealmListChildrenRequest<'_> {
5679 type Constraint = ();
5680
5681 fn validate(
5682 _: ::fidl_next::Slot<'_, Self>,
5683 _: Self::Constraint,
5684 ) -> Result<(), ::fidl_next::ValidationError> {
5685 Ok(())
5686 }
5687 }
5688
5689 unsafe impl ::fidl_next::Wire for RealmListChildrenRequest<'static> {
5690 type Narrowed<'de> = RealmListChildrenRequest<'de>;
5691
5692 #[inline]
5693 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5694 ::fidl_next::munge! {
5695 let Self {
5696 collection,
5697 iter,
5698
5699 } = &mut *out_;
5700 }
5701
5702 ::fidl_next::Wire::zero_padding(collection);
5703
5704 ::fidl_next::Wire::zero_padding(iter);
5705
5706 unsafe {
5707 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5708 }
5709 }
5710 }
5711
5712 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmListChildrenRequest<'de>
5713 where
5714 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5715 ___D: ::fidl_next::Decoder<'de>,
5716 ___D: ::fidl_next::fuchsia::HandleDecoder,
5717 {
5718 fn decode(
5719 slot_: ::fidl_next::Slot<'_, Self>,
5720 decoder_: &mut ___D,
5721 _: (),
5722 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5723 if slot_.as_bytes()[20..24] != [0u8; 4] {
5724 return Err(::fidl_next::DecodeError::InvalidPadding);
5725 }
5726
5727 ::fidl_next::munge! {
5728 let Self {
5729 mut collection,
5730 mut iter,
5731
5732 } = slot_;
5733 }
5734
5735 let _field = collection.as_mut();
5736
5737 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
5738
5739 let _field = iter.as_mut();
5740
5741 ::fidl_next::Decode::decode(iter.as_mut(), decoder_, ())?;
5742
5743 Ok(())
5744 }
5745 }
5746
5747 impl<'de> ::fidl_next::IntoNatural for RealmListChildrenRequest<'de> {
5748 type Natural = crate::natural::RealmListChildrenRequest;
5749 }
5750
5751 #[derive(Debug)]
5753 #[repr(C)]
5754 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5755 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5756 }
5757
5758 static_assertions::const_assert_eq!(
5759 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5760 32
5761 );
5762 static_assertions::const_assert_eq!(
5763 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5764 8
5765 );
5766
5767 static_assertions::const_assert_eq!(
5768 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedRequest<'_>, child),
5769 0
5770 );
5771
5772 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedRequest<'_> {
5773 type Constraint = ();
5774
5775 fn validate(
5776 _: ::fidl_next::Slot<'_, Self>,
5777 _: Self::Constraint,
5778 ) -> Result<(), ::fidl_next::ValidationError> {
5779 Ok(())
5780 }
5781 }
5782
5783 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedRequest<'static> {
5784 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedRequest<'de>;
5785
5786 #[inline]
5787 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5788 ::fidl_next::munge! {
5789 let Self {
5790 child,
5791
5792 } = &mut *out_;
5793 }
5794
5795 ::fidl_next::Wire::zero_padding(child);
5796 }
5797 }
5798
5799 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5800 for RealmGetChildOutputDictionaryDeprecatedRequest<'de>
5801 where
5802 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5803 ___D: ::fidl_next::Decoder<'de>,
5804 ___D: ::fidl_next::fuchsia::HandleDecoder,
5805 {
5806 fn decode(
5807 slot_: ::fidl_next::Slot<'_, Self>,
5808 decoder_: &mut ___D,
5809 _: (),
5810 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5811 ::fidl_next::munge! {
5812 let Self {
5813 mut child,
5814
5815 } = slot_;
5816 }
5817
5818 let _field = child.as_mut();
5819
5820 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5821
5822 Ok(())
5823 }
5824 }
5825
5826 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5827 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
5828 }
5829
5830 #[derive(Debug)]
5832 #[repr(C)]
5833 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
5834 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
5835 }
5836
5837 static_assertions::const_assert_eq!(
5838 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5839 4
5840 );
5841 static_assertions::const_assert_eq!(
5842 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5843 4
5844 );
5845
5846 static_assertions::const_assert_eq!(
5847 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedResponse, dictionary),
5848 0
5849 );
5850
5851 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedResponse {
5852 type Constraint = ();
5853
5854 fn validate(
5855 _: ::fidl_next::Slot<'_, Self>,
5856 _: Self::Constraint,
5857 ) -> Result<(), ::fidl_next::ValidationError> {
5858 Ok(())
5859 }
5860 }
5861
5862 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedResponse {
5863 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedResponse;
5864
5865 #[inline]
5866 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5867 ::fidl_next::munge! {
5868 let Self {
5869 dictionary,
5870
5871 } = &mut *out_;
5872 }
5873
5874 ::fidl_next::Wire::zero_padding(dictionary);
5875 }
5876 }
5877
5878 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryDeprecatedResponse
5879 where
5880 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5881 ___D: ::fidl_next::fuchsia::HandleDecoder,
5882 {
5883 fn decode(
5884 slot_: ::fidl_next::Slot<'_, Self>,
5885 decoder_: &mut ___D,
5886 _: (),
5887 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5888 ::fidl_next::munge! {
5889 let Self {
5890 mut dictionary,
5891
5892 } = slot_;
5893 }
5894
5895 let _field = dictionary.as_mut();
5896
5897 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5898
5899 Ok(())
5900 }
5901 }
5902
5903 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedResponse {
5904 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
5905 }
5906
5907 #[derive(Debug)]
5909 #[repr(C)]
5910 pub struct RealmGetChildOutputDictionaryRequest<'de> {
5911 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5912 }
5913
5914 static_assertions::const_assert_eq!(
5915 std::mem::size_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5916 32
5917 );
5918 static_assertions::const_assert_eq!(
5919 std::mem::align_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5920 8
5921 );
5922
5923 static_assertions::const_assert_eq!(
5924 std::mem::offset_of!(RealmGetChildOutputDictionaryRequest<'_>, child),
5925 0
5926 );
5927
5928 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryRequest<'_> {
5929 type Constraint = ();
5930
5931 fn validate(
5932 _: ::fidl_next::Slot<'_, Self>,
5933 _: Self::Constraint,
5934 ) -> Result<(), ::fidl_next::ValidationError> {
5935 Ok(())
5936 }
5937 }
5938
5939 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryRequest<'static> {
5940 type Narrowed<'de> = RealmGetChildOutputDictionaryRequest<'de>;
5941
5942 #[inline]
5943 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5944 ::fidl_next::munge! {
5945 let Self {
5946 child,
5947
5948 } = &mut *out_;
5949 }
5950
5951 ::fidl_next::Wire::zero_padding(child);
5952 }
5953 }
5954
5955 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryRequest<'de>
5956 where
5957 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5958 ___D: ::fidl_next::Decoder<'de>,
5959 ___D: ::fidl_next::fuchsia::HandleDecoder,
5960 {
5961 fn decode(
5962 slot_: ::fidl_next::Slot<'_, Self>,
5963 decoder_: &mut ___D,
5964 _: (),
5965 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5966 ::fidl_next::munge! {
5967 let Self {
5968 mut child,
5969
5970 } = slot_;
5971 }
5972
5973 let _field = child.as_mut();
5974
5975 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5976
5977 Ok(())
5978 }
5979 }
5980
5981 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryRequest<'de> {
5982 type Natural = crate::natural::RealmGetChildOutputDictionaryRequest;
5983 }
5984
5985 #[derive(Debug)]
5987 #[repr(C)]
5988 pub struct RealmGetChildOutputDictionaryResponse {
5989 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
5990 }
5991
5992 static_assertions::const_assert_eq!(
5993 std::mem::size_of::<RealmGetChildOutputDictionaryResponse>(),
5994 4
5995 );
5996 static_assertions::const_assert_eq!(
5997 std::mem::align_of::<RealmGetChildOutputDictionaryResponse>(),
5998 4
5999 );
6000
6001 static_assertions::const_assert_eq!(
6002 std::mem::offset_of!(RealmGetChildOutputDictionaryResponse, dictionary),
6003 0
6004 );
6005
6006 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryResponse {
6007 type Constraint = ();
6008
6009 fn validate(
6010 _: ::fidl_next::Slot<'_, Self>,
6011 _: Self::Constraint,
6012 ) -> Result<(), ::fidl_next::ValidationError> {
6013 Ok(())
6014 }
6015 }
6016
6017 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryResponse {
6018 type Narrowed<'de> = RealmGetChildOutputDictionaryResponse;
6019
6020 #[inline]
6021 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6022 ::fidl_next::munge! {
6023 let Self {
6024 dictionary,
6025
6026 } = &mut *out_;
6027 }
6028
6029 ::fidl_next::Wire::zero_padding(dictionary);
6030 }
6031 }
6032
6033 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryResponse
6034 where
6035 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6036 ___D: ::fidl_next::fuchsia::HandleDecoder,
6037 {
6038 fn decode(
6039 slot_: ::fidl_next::Slot<'_, Self>,
6040 decoder_: &mut ___D,
6041 _: (),
6042 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6043 ::fidl_next::munge! {
6044 let Self {
6045 mut dictionary,
6046
6047 } = slot_;
6048 }
6049
6050 let _field = dictionary.as_mut();
6051
6052 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
6053
6054 Ok(())
6055 }
6056 }
6057
6058 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryResponse {
6059 type Natural = crate::natural::RealmGetChildOutputDictionaryResponse;
6060 }
6061
6062 #[derive(Debug)]
6064 #[repr(C)]
6065 pub struct RealmOpenControllerRequest<'de> {
6066 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
6067
6068 pub controller:
6069 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
6070 }
6071
6072 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenControllerRequest<'_>>(), 40);
6073 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenControllerRequest<'_>>(), 8);
6074
6075 static_assertions::const_assert_eq!(
6076 std::mem::offset_of!(RealmOpenControllerRequest<'_>, child),
6077 0
6078 );
6079
6080 static_assertions::const_assert_eq!(
6081 std::mem::offset_of!(RealmOpenControllerRequest<'_>, controller),
6082 32
6083 );
6084
6085 impl ::fidl_next::Constrained for RealmOpenControllerRequest<'_> {
6086 type Constraint = ();
6087
6088 fn validate(
6089 _: ::fidl_next::Slot<'_, Self>,
6090 _: Self::Constraint,
6091 ) -> Result<(), ::fidl_next::ValidationError> {
6092 Ok(())
6093 }
6094 }
6095
6096 unsafe impl ::fidl_next::Wire for RealmOpenControllerRequest<'static> {
6097 type Narrowed<'de> = RealmOpenControllerRequest<'de>;
6098
6099 #[inline]
6100 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6101 ::fidl_next::munge! {
6102 let Self {
6103 child,
6104 controller,
6105
6106 } = &mut *out_;
6107 }
6108
6109 ::fidl_next::Wire::zero_padding(child);
6110
6111 ::fidl_next::Wire::zero_padding(controller);
6112
6113 unsafe {
6114 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6115 }
6116 }
6117 }
6118
6119 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenControllerRequest<'de>
6120 where
6121 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6122 ___D: ::fidl_next::Decoder<'de>,
6123 ___D: ::fidl_next::fuchsia::HandleDecoder,
6124 {
6125 fn decode(
6126 slot_: ::fidl_next::Slot<'_, Self>,
6127 decoder_: &mut ___D,
6128 _: (),
6129 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6130 if slot_.as_bytes()[36..40] != [0u8; 4] {
6131 return Err(::fidl_next::DecodeError::InvalidPadding);
6132 }
6133
6134 ::fidl_next::munge! {
6135 let Self {
6136 mut child,
6137 mut controller,
6138
6139 } = slot_;
6140 }
6141
6142 let _field = child.as_mut();
6143
6144 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6145
6146 let _field = controller.as_mut();
6147
6148 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
6149
6150 Ok(())
6151 }
6152 }
6153
6154 impl<'de> ::fidl_next::IntoNatural for RealmOpenControllerRequest<'de> {
6155 type Natural = crate::natural::RealmOpenControllerRequest;
6156 }
6157
6158 #[derive(Debug)]
6160 #[repr(C)]
6161 pub struct RealmOpenExposedDirRequest<'de> {
6162 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
6163
6164 pub exposed_dir: ::fidl_next::ServerEnd<
6165 ::fidl_next_fuchsia_io::Directory,
6166 ::fidl_next::wire::fuchsia::Channel,
6167 >,
6168 }
6169
6170 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenExposedDirRequest<'_>>(), 40);
6171 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenExposedDirRequest<'_>>(), 8);
6172
6173 static_assertions::const_assert_eq!(
6174 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, child),
6175 0
6176 );
6177
6178 static_assertions::const_assert_eq!(
6179 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, exposed_dir),
6180 32
6181 );
6182
6183 impl ::fidl_next::Constrained for RealmOpenExposedDirRequest<'_> {
6184 type Constraint = ();
6185
6186 fn validate(
6187 _: ::fidl_next::Slot<'_, Self>,
6188 _: Self::Constraint,
6189 ) -> Result<(), ::fidl_next::ValidationError> {
6190 Ok(())
6191 }
6192 }
6193
6194 unsafe impl ::fidl_next::Wire for RealmOpenExposedDirRequest<'static> {
6195 type Narrowed<'de> = RealmOpenExposedDirRequest<'de>;
6196
6197 #[inline]
6198 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6199 ::fidl_next::munge! {
6200 let Self {
6201 child,
6202 exposed_dir,
6203
6204 } = &mut *out_;
6205 }
6206
6207 ::fidl_next::Wire::zero_padding(child);
6208
6209 ::fidl_next::Wire::zero_padding(exposed_dir);
6210
6211 unsafe {
6212 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6213 }
6214 }
6215 }
6216
6217 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenExposedDirRequest<'de>
6218 where
6219 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6220 ___D: ::fidl_next::Decoder<'de>,
6221 ___D: ::fidl_next::fuchsia::HandleDecoder,
6222 {
6223 fn decode(
6224 slot_: ::fidl_next::Slot<'_, Self>,
6225 decoder_: &mut ___D,
6226 _: (),
6227 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6228 if slot_.as_bytes()[36..40] != [0u8; 4] {
6229 return Err(::fidl_next::DecodeError::InvalidPadding);
6230 }
6231
6232 ::fidl_next::munge! {
6233 let Self {
6234 mut child,
6235 mut exposed_dir,
6236
6237 } = slot_;
6238 }
6239
6240 let _field = child.as_mut();
6241
6242 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6243
6244 let _field = exposed_dir.as_mut();
6245
6246 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
6247
6248 Ok(())
6249 }
6250 }
6251
6252 impl<'de> ::fidl_next::IntoNatural for RealmOpenExposedDirRequest<'de> {
6253 type Natural = crate::natural::RealmOpenExposedDirRequest;
6254 }
6255
6256 #[derive(Debug)]
6258 #[repr(C)]
6259 pub struct RealmCreateChildRequest<'de> {
6260 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
6261
6262 pub decl: ::fidl_next_fuchsia_component_decl::wire::Child<'de>,
6263
6264 pub args: crate::wire::CreateChildArgs<'de>,
6265 }
6266
6267 static_assertions::const_assert_eq!(std::mem::size_of::<RealmCreateChildRequest<'_>>(), 48);
6268 static_assertions::const_assert_eq!(std::mem::align_of::<RealmCreateChildRequest<'_>>(), 8);
6269
6270 static_assertions::const_assert_eq!(
6271 std::mem::offset_of!(RealmCreateChildRequest<'_>, collection),
6272 0
6273 );
6274
6275 static_assertions::const_assert_eq!(
6276 std::mem::offset_of!(RealmCreateChildRequest<'_>, decl),
6277 16
6278 );
6279
6280 static_assertions::const_assert_eq!(
6281 std::mem::offset_of!(RealmCreateChildRequest<'_>, args),
6282 32
6283 );
6284
6285 impl ::fidl_next::Constrained for RealmCreateChildRequest<'_> {
6286 type Constraint = ();
6287
6288 fn validate(
6289 _: ::fidl_next::Slot<'_, Self>,
6290 _: Self::Constraint,
6291 ) -> Result<(), ::fidl_next::ValidationError> {
6292 Ok(())
6293 }
6294 }
6295
6296 unsafe impl ::fidl_next::Wire for RealmCreateChildRequest<'static> {
6297 type Narrowed<'de> = RealmCreateChildRequest<'de>;
6298
6299 #[inline]
6300 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6301 ::fidl_next::munge! {
6302 let Self {
6303 collection,
6304 decl,
6305 args,
6306
6307 } = &mut *out_;
6308 }
6309
6310 ::fidl_next::Wire::zero_padding(collection);
6311
6312 ::fidl_next::Wire::zero_padding(decl);
6313
6314 ::fidl_next::Wire::zero_padding(args);
6315 }
6316 }
6317
6318 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmCreateChildRequest<'de>
6319 where
6320 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6321 ___D: ::fidl_next::Decoder<'de>,
6322 ___D: ::fidl_next::fuchsia::HandleDecoder,
6323 {
6324 fn decode(
6325 slot_: ::fidl_next::Slot<'_, Self>,
6326 decoder_: &mut ___D,
6327 _: (),
6328 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6329 ::fidl_next::munge! {
6330 let Self {
6331 mut collection,
6332 mut decl,
6333 mut args,
6334
6335 } = slot_;
6336 }
6337
6338 let _field = collection.as_mut();
6339
6340 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
6341
6342 let _field = decl.as_mut();
6343
6344 ::fidl_next::Decode::decode(decl.as_mut(), decoder_, ())?;
6345
6346 let _field = args.as_mut();
6347
6348 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
6349
6350 Ok(())
6351 }
6352 }
6353
6354 impl<'de> ::fidl_next::IntoNatural for RealmCreateChildRequest<'de> {
6355 type Natural = crate::natural::RealmCreateChildRequest;
6356 }
6357
6358 #[derive(Debug)]
6360 #[repr(C)]
6361 pub struct RealmGetResolvedInfoResponse<'de> {
6362 pub resolved_info: ::fidl_next_fuchsia_component_resolution::wire::Component<'de>,
6363 }
6364
6365 static_assertions::const_assert_eq!(
6366 std::mem::size_of::<RealmGetResolvedInfoResponse<'_>>(),
6367 16
6368 );
6369 static_assertions::const_assert_eq!(
6370 std::mem::align_of::<RealmGetResolvedInfoResponse<'_>>(),
6371 8
6372 );
6373
6374 static_assertions::const_assert_eq!(
6375 std::mem::offset_of!(RealmGetResolvedInfoResponse<'_>, resolved_info),
6376 0
6377 );
6378
6379 impl ::fidl_next::Constrained for RealmGetResolvedInfoResponse<'_> {
6380 type Constraint = ();
6381
6382 fn validate(
6383 _: ::fidl_next::Slot<'_, Self>,
6384 _: Self::Constraint,
6385 ) -> Result<(), ::fidl_next::ValidationError> {
6386 Ok(())
6387 }
6388 }
6389
6390 unsafe impl ::fidl_next::Wire for RealmGetResolvedInfoResponse<'static> {
6391 type Narrowed<'de> = RealmGetResolvedInfoResponse<'de>;
6392
6393 #[inline]
6394 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6395 ::fidl_next::munge! {
6396 let Self {
6397 resolved_info,
6398
6399 } = &mut *out_;
6400 }
6401
6402 ::fidl_next::Wire::zero_padding(resolved_info);
6403 }
6404 }
6405
6406 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetResolvedInfoResponse<'de>
6407 where
6408 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6409 ___D: ::fidl_next::Decoder<'de>,
6410 ___D: ::fidl_next::fuchsia::HandleDecoder,
6411 {
6412 fn decode(
6413 slot_: ::fidl_next::Slot<'_, Self>,
6414 decoder_: &mut ___D,
6415 _: (),
6416 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6417 ::fidl_next::munge! {
6418 let Self {
6419 mut resolved_info,
6420
6421 } = slot_;
6422 }
6423
6424 let _field = resolved_info.as_mut();
6425
6426 ::fidl_next::Decode::decode(resolved_info.as_mut(), decoder_, ())?;
6427
6428 Ok(())
6429 }
6430 }
6431
6432 impl<'de> ::fidl_next::IntoNatural for RealmGetResolvedInfoResponse<'de> {
6433 type Natural = crate::natural::RealmGetResolvedInfoResponse;
6434 }
6435
6436 #[derive(Debug)]
6438 #[repr(C)]
6439 pub struct StorageAdminListStorageInRealmRequest<'de> {
6440 pub relative_moniker: ::fidl_next::wire::String<'de>,
6441
6442 pub iterator:
6443 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
6444 }
6445
6446 static_assertions::const_assert_eq!(
6447 std::mem::size_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6448 24
6449 );
6450 static_assertions::const_assert_eq!(
6451 std::mem::align_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6452 8
6453 );
6454
6455 static_assertions::const_assert_eq!(
6456 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, relative_moniker),
6457 0
6458 );
6459
6460 static_assertions::const_assert_eq!(
6461 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, iterator),
6462 16
6463 );
6464
6465 impl ::fidl_next::Constrained for StorageAdminListStorageInRealmRequest<'_> {
6466 type Constraint = ();
6467
6468 fn validate(
6469 _: ::fidl_next::Slot<'_, Self>,
6470 _: Self::Constraint,
6471 ) -> Result<(), ::fidl_next::ValidationError> {
6472 Ok(())
6473 }
6474 }
6475
6476 unsafe impl ::fidl_next::Wire for StorageAdminListStorageInRealmRequest<'static> {
6477 type Narrowed<'de> = StorageAdminListStorageInRealmRequest<'de>;
6478
6479 #[inline]
6480 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6481 ::fidl_next::munge! {
6482 let Self {
6483 relative_moniker,
6484 iterator,
6485
6486 } = &mut *out_;
6487 }
6488
6489 ::fidl_next::Wire::zero_padding(relative_moniker);
6490
6491 ::fidl_next::Wire::zero_padding(iterator);
6492
6493 unsafe {
6494 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6495 }
6496 }
6497 }
6498
6499 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminListStorageInRealmRequest<'de>
6500 where
6501 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6502 ___D: ::fidl_next::Decoder<'de>,
6503 ___D: ::fidl_next::fuchsia::HandleDecoder,
6504 {
6505 fn decode(
6506 slot_: ::fidl_next::Slot<'_, Self>,
6507 decoder_: &mut ___D,
6508 _: (),
6509 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6510 if slot_.as_bytes()[20..24] != [0u8; 4] {
6511 return Err(::fidl_next::DecodeError::InvalidPadding);
6512 }
6513
6514 ::fidl_next::munge! {
6515 let Self {
6516 mut relative_moniker,
6517 mut iterator,
6518
6519 } = slot_;
6520 }
6521
6522 let _field = relative_moniker.as_mut();
6523 ::fidl_next::Constrained::validate(_field, 4096)?;
6524 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6525
6526 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6527
6528 if relative_moniker.len() > 4096 {
6529 return Err(::fidl_next::DecodeError::VectorTooLong {
6530 size: relative_moniker.len() as u64,
6531 limit: 4096,
6532 });
6533 }
6534
6535 let _field = iterator.as_mut();
6536
6537 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
6538
6539 Ok(())
6540 }
6541 }
6542
6543 impl<'de> ::fidl_next::IntoNatural for StorageAdminListStorageInRealmRequest<'de> {
6544 type Natural = crate::natural::StorageAdminListStorageInRealmRequest;
6545 }
6546
6547 #[derive(Debug)]
6549 #[repr(C)]
6550 pub struct StorageAdminOpenStorageRequest<'de> {
6551 pub relative_moniker: ::fidl_next::wire::String<'de>,
6552
6553 pub object: ::fidl_next::ServerEnd<
6554 ::fidl_next_fuchsia_io::Node,
6555 ::fidl_next::wire::fuchsia::Channel,
6556 >,
6557 }
6558
6559 static_assertions::const_assert_eq!(
6560 std::mem::size_of::<StorageAdminOpenStorageRequest<'_>>(),
6561 24
6562 );
6563 static_assertions::const_assert_eq!(
6564 std::mem::align_of::<StorageAdminOpenStorageRequest<'_>>(),
6565 8
6566 );
6567
6568 static_assertions::const_assert_eq!(
6569 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, relative_moniker),
6570 0
6571 );
6572
6573 static_assertions::const_assert_eq!(
6574 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, object),
6575 16
6576 );
6577
6578 impl ::fidl_next::Constrained for StorageAdminOpenStorageRequest<'_> {
6579 type Constraint = ();
6580
6581 fn validate(
6582 _: ::fidl_next::Slot<'_, Self>,
6583 _: Self::Constraint,
6584 ) -> Result<(), ::fidl_next::ValidationError> {
6585 Ok(())
6586 }
6587 }
6588
6589 unsafe impl ::fidl_next::Wire for StorageAdminOpenStorageRequest<'static> {
6590 type Narrowed<'de> = StorageAdminOpenStorageRequest<'de>;
6591
6592 #[inline]
6593 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6594 ::fidl_next::munge! {
6595 let Self {
6596 relative_moniker,
6597 object,
6598
6599 } = &mut *out_;
6600 }
6601
6602 ::fidl_next::Wire::zero_padding(relative_moniker);
6603
6604 ::fidl_next::Wire::zero_padding(object);
6605
6606 unsafe {
6607 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6608 }
6609 }
6610 }
6611
6612 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminOpenStorageRequest<'de>
6613 where
6614 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6615 ___D: ::fidl_next::Decoder<'de>,
6616 ___D: ::fidl_next::fuchsia::HandleDecoder,
6617 {
6618 fn decode(
6619 slot_: ::fidl_next::Slot<'_, Self>,
6620 decoder_: &mut ___D,
6621 _: (),
6622 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6623 if slot_.as_bytes()[20..24] != [0u8; 4] {
6624 return Err(::fidl_next::DecodeError::InvalidPadding);
6625 }
6626
6627 ::fidl_next::munge! {
6628 let Self {
6629 mut relative_moniker,
6630 mut object,
6631
6632 } = slot_;
6633 }
6634
6635 let _field = relative_moniker.as_mut();
6636 ::fidl_next::Constrained::validate(_field, 4096)?;
6637 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6638
6639 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6640
6641 if relative_moniker.len() > 4096 {
6642 return Err(::fidl_next::DecodeError::VectorTooLong {
6643 size: relative_moniker.len() as u64,
6644 limit: 4096,
6645 });
6646 }
6647
6648 let _field = object.as_mut();
6649
6650 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6651
6652 Ok(())
6653 }
6654 }
6655
6656 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenStorageRequest<'de> {
6657 type Natural = crate::natural::StorageAdminOpenStorageRequest;
6658 }
6659
6660 #[derive(Debug)]
6662 #[repr(C)]
6663 pub struct StorageAdminOpenComponentStorageByIdRequest<'de> {
6664 pub id: ::fidl_next::wire::String<'de>,
6665
6666 pub object: ::fidl_next::ServerEnd<
6667 ::fidl_next_fuchsia_io::Node,
6668 ::fidl_next::wire::fuchsia::Channel,
6669 >,
6670 }
6671
6672 static_assertions::const_assert_eq!(
6673 std::mem::size_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6674 24
6675 );
6676 static_assertions::const_assert_eq!(
6677 std::mem::align_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6678 8
6679 );
6680
6681 static_assertions::const_assert_eq!(
6682 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, id),
6683 0
6684 );
6685
6686 static_assertions::const_assert_eq!(
6687 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, object),
6688 16
6689 );
6690
6691 impl ::fidl_next::Constrained for StorageAdminOpenComponentStorageByIdRequest<'_> {
6692 type Constraint = ();
6693
6694 fn validate(
6695 _: ::fidl_next::Slot<'_, Self>,
6696 _: Self::Constraint,
6697 ) -> Result<(), ::fidl_next::ValidationError> {
6698 Ok(())
6699 }
6700 }
6701
6702 unsafe impl ::fidl_next::Wire for StorageAdminOpenComponentStorageByIdRequest<'static> {
6703 type Narrowed<'de> = StorageAdminOpenComponentStorageByIdRequest<'de>;
6704
6705 #[inline]
6706 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6707 ::fidl_next::munge! {
6708 let Self {
6709 id,
6710 object,
6711
6712 } = &mut *out_;
6713 }
6714
6715 ::fidl_next::Wire::zero_padding(id);
6716
6717 ::fidl_next::Wire::zero_padding(object);
6718
6719 unsafe {
6720 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6721 }
6722 }
6723 }
6724
6725 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6726 for StorageAdminOpenComponentStorageByIdRequest<'de>
6727 where
6728 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6729 ___D: ::fidl_next::Decoder<'de>,
6730 ___D: ::fidl_next::fuchsia::HandleDecoder,
6731 {
6732 fn decode(
6733 slot_: ::fidl_next::Slot<'_, Self>,
6734 decoder_: &mut ___D,
6735 _: (),
6736 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6737 if slot_.as_bytes()[20..24] != [0u8; 4] {
6738 return Err(::fidl_next::DecodeError::InvalidPadding);
6739 }
6740
6741 ::fidl_next::munge! {
6742 let Self {
6743 mut id,
6744 mut object,
6745
6746 } = slot_;
6747 }
6748
6749 let _field = id.as_mut();
6750 ::fidl_next::Constrained::validate(_field, 64)?;
6751 ::fidl_next::Decode::decode(id.as_mut(), decoder_, 64)?;
6752
6753 let id = unsafe { id.deref_unchecked() };
6754
6755 if id.len() > 64 {
6756 return Err(::fidl_next::DecodeError::VectorTooLong {
6757 size: id.len() as u64,
6758 limit: 64,
6759 });
6760 }
6761
6762 let _field = object.as_mut();
6763
6764 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6765
6766 Ok(())
6767 }
6768 }
6769
6770 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenComponentStorageByIdRequest<'de> {
6771 type Natural = crate::natural::StorageAdminOpenComponentStorageByIdRequest;
6772 }
6773}
6774
6775pub mod wire_optional {
6776
6777 pub use fidl_next_common_fuchsia_component::wire_optional::*;
6778
6779 #[repr(transparent)]
6780 pub struct EventPayload<'de> {
6781 pub(crate) raw: ::fidl_next::wire::Union,
6782 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6783 }
6784
6785 impl ::fidl_next::Constrained for EventPayload<'_> {
6786 type Constraint = ();
6787
6788 fn validate(
6789 _: ::fidl_next::Slot<'_, Self>,
6790 _: Self::Constraint,
6791 ) -> Result<(), ::fidl_next::ValidationError> {
6792 Ok(())
6793 }
6794 }
6795
6796 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
6797 type Narrowed<'de> = EventPayload<'de>;
6798
6799 #[inline]
6800 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6801 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6802 ::fidl_next::wire::Union::zero_padding(raw);
6803 }
6804 }
6805
6806 impl<'de> EventPayload<'de> {
6807 pub fn is_some(&self) -> bool {
6808 self.raw.is_some()
6809 }
6810
6811 pub fn is_none(&self) -> bool {
6812 self.raw.is_none()
6813 }
6814
6815 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
6816 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6817 }
6818
6819 pub fn into_option(self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
6820 if self.is_some() {
6821 Some(crate::wire::EventPayload {
6822 raw: self.raw,
6823 _phantom: ::core::marker::PhantomData,
6824 })
6825 } else {
6826 None
6827 }
6828 }
6829 }
6830
6831 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
6832 where
6833 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6834 ___D: ::fidl_next::Decoder<'de>,
6835 ___D: ::fidl_next::fuchsia::HandleDecoder,
6836 {
6837 fn decode(
6838 mut slot: ::fidl_next::Slot<'_, Self>,
6839 decoder: &mut ___D,
6840 _: (),
6841 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6842 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6843 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6844 1 => ::fidl_next::wire::Union::decode_as::<
6845 ___D,
6846 crate::wire::CapabilityRequestedPayload<'de>,
6847 >(raw, decoder, ())?,
6848
6849 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
6850 raw,
6851 decoder,
6852 (),
6853 )?,
6854
6855 4 => ::fidl_next::wire::Union::decode_as::<
6856 ___D,
6857 crate::wire::DiscoveredPayload<'de>,
6858 >(raw, decoder, ())?,
6859
6860 5 => {
6861 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
6862 raw,
6863 decoder,
6864 (),
6865 )?
6866 }
6867
6868 6 => {
6869 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
6870 raw,
6871 decoder,
6872 (),
6873 )?
6874 }
6875
6876 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
6877 raw,
6878 decoder,
6879 (),
6880 )?,
6881
6882 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
6883 raw,
6884 decoder,
6885 (),
6886 )?,
6887
6888 9 => ::fidl_next::wire::Union::decode_as::<
6889 ___D,
6890 crate::wire::DebugStartedPayload<'de>,
6891 >(raw, decoder, ())?,
6892
6893 10 => ::fidl_next::wire::Union::decode_as::<
6894 ___D,
6895 crate::wire::UnresolvedPayload<'de>,
6896 >(raw, decoder, ())?,
6897
6898 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
6899 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
6900 }
6901
6902 Ok(())
6903 }
6904 }
6905
6906 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
6907 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6908 self.as_ref().fmt(f)
6909 }
6910 }
6911
6912 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
6913 type Natural = ::core::option::Option<crate::natural::EventPayload>;
6914 }
6915}
6916
6917pub mod generic {
6918
6919 pub use fidl_next_common_fuchsia_component::generic::*;
6920
6921 pub struct ControllerIsStartedResponse<T0> {
6923 pub is_started: T0,
6924 }
6925
6926 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6927 for ControllerIsStartedResponse<T0>
6928 where
6929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6930 ___E: ::fidl_next::fuchsia::HandleEncoder,
6931 T0: ::fidl_next::Encode<bool, ___E>,
6932 {
6933 #[inline]
6934 fn encode(
6935 self,
6936 encoder_: &mut ___E,
6937 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6938 _: (),
6939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6940 ::fidl_next::munge! {
6941 let crate::wire::ControllerIsStartedResponse {
6942 is_started,
6943
6944 } = out_;
6945 }
6946
6947 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
6948
6949 Ok(())
6950 }
6951 }
6952
6953 pub struct ControllerGetExposedDictionaryResponse<T0> {
6955 pub dictionary: T0,
6956 }
6957
6958 unsafe impl<___E, T0>
6959 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
6960 for ControllerGetExposedDictionaryResponse<T0>
6961 where
6962 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6963 ___E: ::fidl_next::fuchsia::HandleEncoder,
6964 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
6965 {
6966 #[inline]
6967 fn encode(
6968 self,
6969 encoder_: &mut ___E,
6970 out_: &mut ::core::mem::MaybeUninit<
6971 crate::wire::ControllerGetExposedDictionaryResponse,
6972 >,
6973 _: (),
6974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6975 ::fidl_next::munge! {
6976 let crate::wire::ControllerGetExposedDictionaryResponse {
6977 dictionary,
6978
6979 } = out_;
6980 }
6981
6982 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6983
6984 Ok(())
6985 }
6986 }
6987
6988 pub struct ControllerGetOutputDictionaryResponse<T0> {
6990 pub dictionary: T0,
6991 }
6992
6993 unsafe impl<___E, T0>
6994 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
6995 for ControllerGetOutputDictionaryResponse<T0>
6996 where
6997 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6998 ___E: ::fidl_next::fuchsia::HandleEncoder,
6999 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7000 {
7001 #[inline]
7002 fn encode(
7003 self,
7004 encoder_: &mut ___E,
7005 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
7006 _: (),
7007 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7008 ::fidl_next::munge! {
7009 let crate::wire::ControllerGetOutputDictionaryResponse {
7010 dictionary,
7011
7012 } = out_;
7013 }
7014
7015 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7016
7017 Ok(())
7018 }
7019 }
7020
7021 pub struct ControllerStartRequest<T0, T1> {
7023 pub args: T0,
7024
7025 pub execution_controller: T1,
7026 }
7027
7028 unsafe impl<___E, T0, T1>
7029 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
7030 for ControllerStartRequest<T0, T1>
7031 where
7032 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7033 ___E: ::fidl_next::Encoder,
7034 ___E: ::fidl_next::fuchsia::HandleEncoder,
7035 T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
7036 T1: ::fidl_next::Encode<
7037 ::fidl_next::ServerEnd<
7038 crate::ExecutionController,
7039 ::fidl_next::wire::fuchsia::Channel,
7040 >,
7041 ___E,
7042 >,
7043 {
7044 #[inline]
7045 fn encode(
7046 self,
7047 encoder_: &mut ___E,
7048 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
7049 _: (),
7050 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7051 ::fidl_next::munge! {
7052 let crate::wire::ControllerStartRequest {
7053 args,
7054 execution_controller,
7055
7056 } = out_;
7057 }
7058
7059 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7060
7061 ::fidl_next::Encode::encode(
7062 self.execution_controller,
7063 encoder_,
7064 execution_controller,
7065 (),
7066 )?;
7067
7068 Ok(())
7069 }
7070 }
7071
7072 pub struct ControllerOpenExposedDirRequest<T0> {
7074 pub exposed_dir: T0,
7075 }
7076
7077 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
7078 for ControllerOpenExposedDirRequest<T0>
7079 where
7080 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7081 ___E: ::fidl_next::fuchsia::HandleEncoder,
7082 T0: ::fidl_next::Encode<
7083 ::fidl_next::ServerEnd<
7084 ::fidl_next_fuchsia_io::Directory,
7085 ::fidl_next::wire::fuchsia::Channel,
7086 >,
7087 ___E,
7088 >,
7089 {
7090 #[inline]
7091 fn encode(
7092 self,
7093 encoder_: &mut ___E,
7094 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
7095 _: (),
7096 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7097 ::fidl_next::munge! {
7098 let crate::wire::ControllerOpenExposedDirRequest {
7099 exposed_dir,
7100
7101 } = out_;
7102 }
7103
7104 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7105
7106 Ok(())
7107 }
7108 }
7109
7110 pub struct EventStreamGetNextResponse<T0> {
7112 pub events: T0,
7113 }
7114
7115 unsafe impl<___E, T0>
7116 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
7117 for EventStreamGetNextResponse<T0>
7118 where
7119 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7120 ___E: ::fidl_next::Encoder,
7121 ___E: ::fidl_next::fuchsia::HandleEncoder,
7122 T0: ::fidl_next::Encode<
7123 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
7124 ___E,
7125 >,
7126 {
7127 #[inline]
7128 fn encode(
7129 self,
7130 encoder_: &mut ___E,
7131 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
7132 _: (),
7133 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7134 ::fidl_next::munge! {
7135 let crate::wire::EventStreamGetNextResponse {
7136 events,
7137
7138 } = out_;
7139 }
7140
7141 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
7142
7143 Ok(())
7144 }
7145 }
7146
7147 pub struct IntrospectorGetMonikerRequest<T0> {
7149 pub component_instance: T0,
7150 }
7151
7152 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
7153 for IntrospectorGetMonikerRequest<T0>
7154 where
7155 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7156 ___E: ::fidl_next::fuchsia::HandleEncoder,
7157 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
7158 {
7159 #[inline]
7160 fn encode(
7161 self,
7162 encoder_: &mut ___E,
7163 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
7164 _: (),
7165 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7166 ::fidl_next::munge! {
7167 let crate::wire::IntrospectorGetMonikerRequest {
7168 component_instance,
7169
7170 } = out_;
7171 }
7172
7173 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
7174
7175 Ok(())
7176 }
7177 }
7178
7179 pub struct NamespaceInputEntry<T0, T1> {
7181 pub path: T0,
7182
7183 pub dictionary: T1,
7184 }
7185
7186 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7187 for NamespaceInputEntry<T0, T1>
7188 where
7189 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7190 ___E: ::fidl_next::Encoder,
7191 ___E: ::fidl_next::fuchsia::HandleEncoder,
7192 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7193 T1: ::fidl_next::Encode<
7194 ::fidl_next::ClientEnd<
7195 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7196 ::fidl_next::wire::fuchsia::Channel,
7197 >,
7198 ___E,
7199 >,
7200 {
7201 #[inline]
7202 fn encode(
7203 self,
7204 encoder_: &mut ___E,
7205 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7206 _: (),
7207 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7208 ::fidl_next::munge! {
7209 let crate::wire::NamespaceInputEntry {
7210 path,
7211 dictionary,
7212
7213 } = out_;
7214 }
7215
7216 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7217
7218 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7219
7220 Ok(())
7221 }
7222 }
7223
7224 pub struct NamespaceCreateRequest<T0> {
7226 pub entries: T0,
7227 }
7228
7229 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7230 for NamespaceCreateRequest<T0>
7231 where
7232 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7233 ___E: ::fidl_next::Encoder,
7234 ___E: ::fidl_next::fuchsia::HandleEncoder,
7235 T0: ::fidl_next::Encode<
7236 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7237 ___E,
7238 >,
7239 {
7240 #[inline]
7241 fn encode(
7242 self,
7243 encoder_: &mut ___E,
7244 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7245 _: (),
7246 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7247 ::fidl_next::munge! {
7248 let crate::wire::NamespaceCreateRequest {
7249 entries,
7250
7251 } = out_;
7252 }
7253
7254 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7255
7256 Ok(())
7257 }
7258 }
7259
7260 pub struct NamespaceInputEntry2<T0, T1> {
7262 pub path: T0,
7263
7264 pub capability: T1,
7265 }
7266
7267 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7268 for NamespaceInputEntry2<T0, T1>
7269 where
7270 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7271 ___E: ::fidl_next::Encoder,
7272 ___E: ::fidl_next::fuchsia::HandleEncoder,
7273 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7274 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7275 {
7276 #[inline]
7277 fn encode(
7278 self,
7279 encoder_: &mut ___E,
7280 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7281 _: (),
7282 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7283 ::fidl_next::munge! {
7284 let crate::wire::NamespaceInputEntry2 {
7285 path,
7286 capability,
7287
7288 } = out_;
7289 }
7290
7291 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7292
7293 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7294
7295 Ok(())
7296 }
7297 }
7298
7299 pub struct NamespaceCreate2Request<T0> {
7301 pub entries: T0,
7302 }
7303
7304 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7305 for NamespaceCreate2Request<T0>
7306 where
7307 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7308 ___E: ::fidl_next::Encoder,
7309 ___E: ::fidl_next::fuchsia::HandleEncoder,
7310 T0: ::fidl_next::Encode<
7311 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7312 ___E,
7313 >,
7314 {
7315 #[inline]
7316 fn encode(
7317 self,
7318 encoder_: &mut ___E,
7319 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7320 _: (),
7321 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7322 ::fidl_next::munge! {
7323 let crate::wire::NamespaceCreate2Request {
7324 entries,
7325
7326 } = out_;
7327 }
7328
7329 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7330
7331 Ok(())
7332 }
7333 }
7334
7335 pub struct NamespaceCreateResponse<T0> {
7337 pub entries: T0,
7338 }
7339
7340 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7341 for NamespaceCreateResponse<T0>
7342 where
7343 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7344 ___E: ::fidl_next::Encoder,
7345 ___E: ::fidl_next::fuchsia::HandleEncoder,
7346 T0: ::fidl_next::Encode<
7347 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7348 ___E,
7349 >,
7350 {
7351 #[inline]
7352 fn encode(
7353 self,
7354 encoder_: &mut ___E,
7355 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7356 _: (),
7357 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7358 ::fidl_next::munge! {
7359 let crate::wire::NamespaceCreateResponse {
7360 entries,
7361
7362 } = out_;
7363 }
7364
7365 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7366
7367 Ok(())
7368 }
7369 }
7370
7371 pub struct NamespaceCreate2Response<T0> {
7373 pub entries: T0,
7374 }
7375
7376 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7377 for NamespaceCreate2Response<T0>
7378 where
7379 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7380 ___E: ::fidl_next::Encoder,
7381 ___E: ::fidl_next::fuchsia::HandleEncoder,
7382 T0: ::fidl_next::Encode<
7383 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7384 ___E,
7385 >,
7386 {
7387 #[inline]
7388 fn encode(
7389 self,
7390 encoder_: &mut ___E,
7391 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7392 _: (),
7393 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7394 ::fidl_next::munge! {
7395 let crate::wire::NamespaceCreate2Response {
7396 entries,
7397
7398 } = out_;
7399 }
7400
7401 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7402
7403 Ok(())
7404 }
7405 }
7406
7407 pub struct RealmListChildrenRequest<T0, T1> {
7409 pub collection: T0,
7410
7411 pub iter: T1,
7412 }
7413
7414 unsafe impl<___E, T0, T1>
7415 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7416 for RealmListChildrenRequest<T0, T1>
7417 where
7418 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7419 ___E: ::fidl_next::Encoder,
7420 ___E: ::fidl_next::fuchsia::HandleEncoder,
7421 T0: ::fidl_next::Encode<
7422 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7423 ___E,
7424 >,
7425 T1: ::fidl_next::Encode<
7426 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7427 ___E,
7428 >,
7429 {
7430 #[inline]
7431 fn encode(
7432 self,
7433 encoder_: &mut ___E,
7434 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7435 _: (),
7436 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7437 ::fidl_next::munge! {
7438 let crate::wire::RealmListChildrenRequest {
7439 collection,
7440 iter,
7441
7442 } = out_;
7443 }
7444
7445 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7446
7447 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
7448
7449 Ok(())
7450 }
7451 }
7452
7453 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<T0> {
7455 pub child: T0,
7456 }
7457
7458 unsafe impl<___E, T0>
7459 ::fidl_next::Encode<
7460 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7461 ___E,
7462 > for RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7463 where
7464 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7465 ___E: ::fidl_next::Encoder,
7466 ___E: ::fidl_next::fuchsia::HandleEncoder,
7467 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7468 {
7469 #[inline]
7470 fn encode(
7471 self,
7472 encoder_: &mut ___E,
7473 out_: &mut ::core::mem::MaybeUninit<
7474 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7475 >,
7476 _: (),
7477 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7478 ::fidl_next::munge! {
7479 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7480 child,
7481
7482 } = out_;
7483 }
7484
7485 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7486
7487 Ok(())
7488 }
7489 }
7490
7491 pub struct RealmGetChildOutputDictionaryDeprecatedResponse<T0> {
7493 pub dictionary: T0,
7494 }
7495
7496 unsafe impl<___E, T0>
7497 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
7498 for RealmGetChildOutputDictionaryDeprecatedResponse<T0>
7499 where
7500 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7501 ___E: ::fidl_next::fuchsia::HandleEncoder,
7502 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
7503 {
7504 #[inline]
7505 fn encode(
7506 self,
7507 encoder_: &mut ___E,
7508 out_: &mut ::core::mem::MaybeUninit<
7509 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
7510 >,
7511 _: (),
7512 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7513 ::fidl_next::munge! {
7514 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
7515 dictionary,
7516
7517 } = out_;
7518 }
7519
7520 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7521
7522 Ok(())
7523 }
7524 }
7525
7526 pub struct RealmGetChildOutputDictionaryRequest<T0> {
7528 pub child: T0,
7529 }
7530
7531 unsafe impl<___E, T0>
7532 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
7533 for RealmGetChildOutputDictionaryRequest<T0>
7534 where
7535 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7536 ___E: ::fidl_next::Encoder,
7537 ___E: ::fidl_next::fuchsia::HandleEncoder,
7538 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7539 {
7540 #[inline]
7541 fn encode(
7542 self,
7543 encoder_: &mut ___E,
7544 out_: &mut ::core::mem::MaybeUninit<
7545 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
7546 >,
7547 _: (),
7548 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7549 ::fidl_next::munge! {
7550 let crate::wire::RealmGetChildOutputDictionaryRequest {
7551 child,
7552
7553 } = out_;
7554 }
7555
7556 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7557
7558 Ok(())
7559 }
7560 }
7561
7562 pub struct RealmGetChildOutputDictionaryResponse<T0> {
7564 pub dictionary: T0,
7565 }
7566
7567 unsafe impl<___E, T0>
7568 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
7569 for RealmGetChildOutputDictionaryResponse<T0>
7570 where
7571 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7572 ___E: ::fidl_next::fuchsia::HandleEncoder,
7573 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7574 {
7575 #[inline]
7576 fn encode(
7577 self,
7578 encoder_: &mut ___E,
7579 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
7580 _: (),
7581 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7582 ::fidl_next::munge! {
7583 let crate::wire::RealmGetChildOutputDictionaryResponse {
7584 dictionary,
7585
7586 } = out_;
7587 }
7588
7589 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7590
7591 Ok(())
7592 }
7593 }
7594
7595 pub struct RealmOpenControllerRequest<T0, T1> {
7597 pub child: T0,
7598
7599 pub controller: T1,
7600 }
7601
7602 unsafe impl<___E, T0, T1>
7603 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
7604 for RealmOpenControllerRequest<T0, T1>
7605 where
7606 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7607 ___E: ::fidl_next::Encoder,
7608 ___E: ::fidl_next::fuchsia::HandleEncoder,
7609 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7610 T1: ::fidl_next::Encode<
7611 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
7612 ___E,
7613 >,
7614 {
7615 #[inline]
7616 fn encode(
7617 self,
7618 encoder_: &mut ___E,
7619 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
7620 _: (),
7621 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7622 ::fidl_next::munge! {
7623 let crate::wire::RealmOpenControllerRequest {
7624 child,
7625 controller,
7626
7627 } = out_;
7628 }
7629
7630 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7631
7632 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
7633
7634 Ok(())
7635 }
7636 }
7637
7638 pub struct RealmOpenExposedDirRequest<T0, T1> {
7640 pub child: T0,
7641
7642 pub exposed_dir: T1,
7643 }
7644
7645 unsafe impl<___E, T0, T1>
7646 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
7647 for RealmOpenExposedDirRequest<T0, T1>
7648 where
7649 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7650 ___E: ::fidl_next::Encoder,
7651 ___E: ::fidl_next::fuchsia::HandleEncoder,
7652 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7653 T1: ::fidl_next::Encode<
7654 ::fidl_next::ServerEnd<
7655 ::fidl_next_fuchsia_io::Directory,
7656 ::fidl_next::wire::fuchsia::Channel,
7657 >,
7658 ___E,
7659 >,
7660 {
7661 #[inline]
7662 fn encode(
7663 self,
7664 encoder_: &mut ___E,
7665 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
7666 _: (),
7667 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7668 ::fidl_next::munge! {
7669 let crate::wire::RealmOpenExposedDirRequest {
7670 child,
7671 exposed_dir,
7672
7673 } = out_;
7674 }
7675
7676 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7677
7678 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7679
7680 Ok(())
7681 }
7682 }
7683
7684 pub struct RealmCreateChildRequest<T0, T1, T2> {
7686 pub collection: T0,
7687
7688 pub decl: T1,
7689
7690 pub args: T2,
7691 }
7692
7693 unsafe impl<___E, T0, T1, T2>
7694 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
7695 for RealmCreateChildRequest<T0, T1, T2>
7696 where
7697 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7698 ___E: ::fidl_next::Encoder,
7699 ___E: ::fidl_next::fuchsia::HandleEncoder,
7700 T0: ::fidl_next::Encode<
7701 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7702 ___E,
7703 >,
7704 T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
7705 T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
7706 {
7707 #[inline]
7708 fn encode(
7709 self,
7710 encoder_: &mut ___E,
7711 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
7712 _: (),
7713 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7714 ::fidl_next::munge! {
7715 let crate::wire::RealmCreateChildRequest {
7716 collection,
7717 decl,
7718 args,
7719
7720 } = out_;
7721 }
7722
7723 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7724
7725 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
7726
7727 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7728
7729 Ok(())
7730 }
7731 }
7732
7733 pub struct RealmGetResolvedInfoResponse<T0> {
7735 pub resolved_info: T0,
7736 }
7737
7738 unsafe impl<___E, T0>
7739 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
7740 for RealmGetResolvedInfoResponse<T0>
7741 where
7742 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7743 ___E: ::fidl_next::Encoder,
7744 ___E: ::fidl_next::fuchsia::HandleEncoder,
7745 T0: ::fidl_next::Encode<
7746 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
7747 ___E,
7748 >,
7749 {
7750 #[inline]
7751 fn encode(
7752 self,
7753 encoder_: &mut ___E,
7754 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
7755 _: (),
7756 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7757 ::fidl_next::munge! {
7758 let crate::wire::RealmGetResolvedInfoResponse {
7759 resolved_info,
7760
7761 } = out_;
7762 }
7763
7764 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
7765
7766 Ok(())
7767 }
7768 }
7769
7770 pub struct StorageAdminListStorageInRealmRequest<T0, T1> {
7772 pub relative_moniker: T0,
7773
7774 pub iterator: T1,
7775 }
7776
7777 unsafe impl<___E, T0, T1>
7778 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
7779 for StorageAdminListStorageInRealmRequest<T0, T1>
7780 where
7781 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7782 ___E: ::fidl_next::Encoder,
7783 ___E: ::fidl_next::fuchsia::HandleEncoder,
7784 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7785 T1: ::fidl_next::Encode<
7786 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
7787 ___E,
7788 >,
7789 {
7790 #[inline]
7791 fn encode(
7792 self,
7793 encoder_: &mut ___E,
7794 out_: &mut ::core::mem::MaybeUninit<
7795 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
7796 >,
7797 _: (),
7798 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7799 ::fidl_next::munge! {
7800 let crate::wire::StorageAdminListStorageInRealmRequest {
7801 relative_moniker,
7802 iterator,
7803
7804 } = out_;
7805 }
7806
7807 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7808
7809 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7810
7811 Ok(())
7812 }
7813 }
7814
7815 pub struct StorageAdminOpenStorageRequest<T0, T1> {
7817 pub relative_moniker: T0,
7818
7819 pub object: T1,
7820 }
7821
7822 unsafe impl<___E, T0, T1>
7823 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
7824 for StorageAdminOpenStorageRequest<T0, T1>
7825 where
7826 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7827 ___E: ::fidl_next::Encoder,
7828 ___E: ::fidl_next::fuchsia::HandleEncoder,
7829 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7830 T1: ::fidl_next::Encode<
7831 ::fidl_next::ServerEnd<
7832 ::fidl_next_fuchsia_io::Node,
7833 ::fidl_next::wire::fuchsia::Channel,
7834 >,
7835 ___E,
7836 >,
7837 {
7838 #[inline]
7839 fn encode(
7840 self,
7841 encoder_: &mut ___E,
7842 out_: &mut ::core::mem::MaybeUninit<
7843 crate::wire::StorageAdminOpenStorageRequest<'static>,
7844 >,
7845 _: (),
7846 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7847 ::fidl_next::munge! {
7848 let crate::wire::StorageAdminOpenStorageRequest {
7849 relative_moniker,
7850 object,
7851
7852 } = out_;
7853 }
7854
7855 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7856
7857 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7858
7859 Ok(())
7860 }
7861 }
7862
7863 pub struct StorageAdminOpenComponentStorageByIdRequest<T0, T1> {
7865 pub id: T0,
7866
7867 pub object: T1,
7868 }
7869
7870 unsafe impl<___E, T0, T1>
7871 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
7872 for StorageAdminOpenComponentStorageByIdRequest<T0, T1>
7873 where
7874 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7875 ___E: ::fidl_next::Encoder,
7876 ___E: ::fidl_next::fuchsia::HandleEncoder,
7877 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7878 T1: ::fidl_next::Encode<
7879 ::fidl_next::ServerEnd<
7880 ::fidl_next_fuchsia_io::Node,
7881 ::fidl_next::wire::fuchsia::Channel,
7882 >,
7883 ___E,
7884 >,
7885 {
7886 #[inline]
7887 fn encode(
7888 self,
7889 encoder_: &mut ___E,
7890 out_: &mut ::core::mem::MaybeUninit<
7891 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
7892 >,
7893 _: (),
7894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7895 ::fidl_next::munge! {
7896 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
7897 id,
7898 object,
7899
7900 } = out_;
7901 }
7902
7903 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
7904
7905 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7906
7907 Ok(())
7908 }
7909 }
7910}
7911
7912pub use self::natural::*;
7913
7914#[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"]
7916#[derive(PartialEq, Debug)]
7917pub struct Controller;
7918
7919#[cfg(target_os = "fuchsia")]
7920impl ::fidl_next::HasTransport for Controller {
7921 type Transport = ::fidl_next::fuchsia::zx::Channel;
7922}
7923
7924pub mod controller {
7925 pub mod prelude {
7926 pub use crate::{
7927 Controller, ControllerClientHandler, ControllerLocalClientHandler,
7928 ControllerLocalServerHandler, ControllerServerHandler, controller,
7929 };
7930
7931 pub use crate::natural::ControllerOpenExposedDirRequest;
7932
7933 pub use crate::natural::ControllerStartRequest;
7934
7935 pub use crate::natural::ControllerDestroyResponse;
7936
7937 pub use crate::natural::ControllerGetExposedDictionaryResponse;
7938
7939 pub use crate::natural::ControllerGetOutputDictionaryResponse;
7940
7941 pub use crate::natural::ControllerIsStartedResponse;
7942
7943 pub use crate::natural::ControllerOpenExposedDirResponse;
7944
7945 pub use crate::natural::ControllerStartResponse;
7946
7947 pub use crate::natural::Error;
7948 }
7949
7950 pub struct Start;
7951
7952 impl ::fidl_next::Method for Start {
7953 const ORDINAL: u64 = 7532130149195770565;
7954 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7955 ::fidl_next::protocol::Flexibility::Flexible;
7956
7957 type Protocol = crate::Controller;
7958
7959 type Request = crate::wire::ControllerStartRequest<'static>;
7960 }
7961
7962 impl ::fidl_next::TwoWayMethod for Start {
7963 type Response = ::fidl_next::wire::Result<
7964 'static,
7965 crate::wire::ControllerStartResponse,
7966 crate::wire::Error,
7967 >;
7968 }
7969
7970 impl<___R> ::fidl_next::Respond<___R> for Start {
7971 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
7972
7973 fn respond(response: ___R) -> Self::Output {
7974 ::core::result::Result::Ok(response)
7975 }
7976 }
7977
7978 impl<___R> ::fidl_next::RespondErr<___R> for Start {
7979 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
7980
7981 fn respond_err(response: ___R) -> Self::Output {
7982 ::core::result::Result::Err(response)
7983 }
7984 }
7985
7986 pub struct IsStarted;
7987
7988 impl ::fidl_next::Method for IsStarted {
7989 const ORDINAL: u64 = 2402079833990398915;
7990 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7991 ::fidl_next::protocol::Flexibility::Flexible;
7992
7993 type Protocol = crate::Controller;
7994
7995 type Request = ::fidl_next::wire::EmptyMessageBody;
7996 }
7997
7998 impl ::fidl_next::TwoWayMethod for IsStarted {
7999 type Response = ::fidl_next::wire::Result<
8000 'static,
8001 crate::wire::ControllerIsStartedResponse,
8002 crate::wire::Error,
8003 >;
8004 }
8005
8006 impl<___R> ::fidl_next::Respond<___R> for IsStarted {
8007 type Output = ::core::result::Result<
8008 crate::generic::ControllerIsStartedResponse<___R>,
8009 ::fidl_next::never::Never,
8010 >;
8011
8012 fn respond(response: ___R) -> Self::Output {
8013 ::core::result::Result::Ok(crate::generic::ControllerIsStartedResponse {
8014 is_started: response,
8015 })
8016 }
8017 }
8018
8019 impl<___R> ::fidl_next::RespondErr<___R> for IsStarted {
8020 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8021
8022 fn respond_err(response: ___R) -> Self::Output {
8023 ::core::result::Result::Err(response)
8024 }
8025 }
8026
8027 pub struct OpenExposedDir;
8028
8029 impl ::fidl_next::Method for OpenExposedDir {
8030 const ORDINAL: u64 = 2683208291886099860;
8031 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8032 ::fidl_next::protocol::Flexibility::Strict;
8033
8034 type Protocol = crate::Controller;
8035
8036 type Request = crate::wire::ControllerOpenExposedDirRequest;
8037 }
8038
8039 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
8040 type Response = ::fidl_next::wire::Result<
8041 'static,
8042 crate::wire::ControllerOpenExposedDirResponse,
8043 crate::wire::Error,
8044 >;
8045 }
8046
8047 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
8048 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
8049
8050 fn respond(response: ___R) -> Self::Output {
8051 ::core::result::Result::Ok(response)
8052 }
8053 }
8054
8055 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
8056 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8057
8058 fn respond_err(response: ___R) -> Self::Output {
8059 ::core::result::Result::Err(response)
8060 }
8061 }
8062
8063 pub struct GetExposedDictionary;
8064
8065 impl ::fidl_next::Method for GetExposedDictionary {
8066 const ORDINAL: u64 = 9099583788120940443;
8067 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8068 ::fidl_next::protocol::Flexibility::Flexible;
8069
8070 type Protocol = crate::Controller;
8071
8072 type Request = ::fidl_next::wire::EmptyMessageBody;
8073 }
8074
8075 impl ::fidl_next::TwoWayMethod for GetExposedDictionary {
8076 type Response = ::fidl_next::wire::Result<
8077 'static,
8078 crate::wire::ControllerGetExposedDictionaryResponse,
8079 crate::wire::Error,
8080 >;
8081 }
8082
8083 impl<___R> ::fidl_next::Respond<___R> for GetExposedDictionary {
8084 type Output = ::core::result::Result<
8085 crate::generic::ControllerGetExposedDictionaryResponse<___R>,
8086 ::fidl_next::never::Never,
8087 >;
8088
8089 fn respond(response: ___R) -> Self::Output {
8090 ::core::result::Result::Ok(crate::generic::ControllerGetExposedDictionaryResponse {
8091 dictionary: response,
8092 })
8093 }
8094 }
8095
8096 impl<___R> ::fidl_next::RespondErr<___R> for GetExposedDictionary {
8097 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8098
8099 fn respond_err(response: ___R) -> Self::Output {
8100 ::core::result::Result::Err(response)
8101 }
8102 }
8103
8104 pub struct GetOutputDictionary;
8105
8106 impl ::fidl_next::Method for GetOutputDictionary {
8107 const ORDINAL: u64 = 4182795765624263201;
8108 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8109 ::fidl_next::protocol::Flexibility::Flexible;
8110
8111 type Protocol = crate::Controller;
8112
8113 type Request = ::fidl_next::wire::EmptyMessageBody;
8114 }
8115
8116 impl ::fidl_next::TwoWayMethod for GetOutputDictionary {
8117 type Response = ::fidl_next::wire::Result<
8118 'static,
8119 crate::wire::ControllerGetOutputDictionaryResponse,
8120 crate::wire::Error,
8121 >;
8122 }
8123
8124 impl<___R> ::fidl_next::Respond<___R> for GetOutputDictionary {
8125 type Output = ::core::result::Result<
8126 crate::generic::ControllerGetOutputDictionaryResponse<___R>,
8127 ::fidl_next::never::Never,
8128 >;
8129
8130 fn respond(response: ___R) -> Self::Output {
8131 ::core::result::Result::Ok(crate::generic::ControllerGetOutputDictionaryResponse {
8132 dictionary: response,
8133 })
8134 }
8135 }
8136
8137 impl<___R> ::fidl_next::RespondErr<___R> for GetOutputDictionary {
8138 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8139
8140 fn respond_err(response: ___R) -> Self::Output {
8141 ::core::result::Result::Err(response)
8142 }
8143 }
8144
8145 pub struct Destroy;
8146
8147 impl ::fidl_next::Method for Destroy {
8148 const ORDINAL: u64 = 8381937394141370177;
8149 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8150 ::fidl_next::protocol::Flexibility::Flexible;
8151
8152 type Protocol = crate::Controller;
8153
8154 type Request = ::fidl_next::wire::EmptyMessageBody;
8155 }
8156
8157 impl ::fidl_next::TwoWayMethod for Destroy {
8158 type Response = ::fidl_next::wire::Result<
8159 'static,
8160 crate::wire::ControllerDestroyResponse,
8161 crate::wire::Error,
8162 >;
8163 }
8164
8165 impl<___R> ::fidl_next::Respond<___R> for Destroy {
8166 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
8167
8168 fn respond(response: ___R) -> Self::Output {
8169 ::core::result::Result::Ok(response)
8170 }
8171 }
8172
8173 impl<___R> ::fidl_next::RespondErr<___R> for Destroy {
8174 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
8175
8176 fn respond_err(response: ___R) -> Self::Output {
8177 ::core::result::Result::Err(response)
8178 }
8179 }
8180
8181 mod ___detail {
8182 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Controller
8183 where
8184 ___T: ::fidl_next::Transport,
8185 {
8186 type Client = ControllerClient<___T>;
8187 type Server = ControllerServer<___T>;
8188 }
8189
8190 #[repr(transparent)]
8192 pub struct ControllerClient<___T: ::fidl_next::Transport> {
8193 #[allow(dead_code)]
8194 client: ::fidl_next::protocol::Client<___T>,
8195 }
8196
8197 impl<___T> ControllerClient<___T>
8198 where
8199 ___T: ::fidl_next::Transport,
8200 {
8201 #[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"]
8202 pub fn start(
8203 &self,
8204
8205 args: impl ::fidl_next::Encode<
8206 crate::wire::StartChildArgs<'static>,
8207 <___T as ::fidl_next::Transport>::SendBuffer,
8208 >,
8209
8210 execution_controller: impl ::fidl_next::Encode<
8211 ::fidl_next::ServerEnd<
8212 crate::ExecutionController,
8213 ::fidl_next::wire::fuchsia::Channel,
8214 >,
8215 <___T as ::fidl_next::Transport>::SendBuffer,
8216 >,
8217 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8218 where
8219 <___T as ::fidl_next::Transport>::SendBuffer:
8220 ::fidl_next::encoder::InternalHandleEncoder,
8221 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8222 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8223 {
8224 self.start_with(crate::generic::ControllerStartRequest {
8225 args,
8226
8227 execution_controller,
8228 })
8229 }
8230
8231 #[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"]
8232 pub fn start_with<___R>(
8233 &self,
8234 request: ___R,
8235 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8236 where
8237 ___R: ::fidl_next::Encode<
8238 crate::wire::ControllerStartRequest<'static>,
8239 <___T as ::fidl_next::Transport>::SendBuffer,
8240 >,
8241 {
8242 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8243 7532130149195770565,
8244 <super::Start as ::fidl_next::Method>::FLEXIBILITY,
8245 request,
8246 ))
8247 }
8248
8249 #[doc = " Returns true if this instance is currently running.\n"]
8250 pub fn is_started(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsStarted, ___T> {
8251 ::fidl_next::TwoWayFuture::from_untyped(
8252 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8253 2402079833990398915,
8254 <super::IsStarted as ::fidl_next::Method>::FLEXIBILITY,
8255 (),
8256 ),
8257 )
8258 }
8259
8260 #[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"]
8261 pub fn open_exposed_dir(
8262 &self,
8263
8264 exposed_dir: impl ::fidl_next::Encode<
8265 ::fidl_next::ServerEnd<
8266 ::fidl_next_fuchsia_io::Directory,
8267 ::fidl_next::wire::fuchsia::Channel,
8268 >,
8269 <___T as ::fidl_next::Transport>::SendBuffer,
8270 >,
8271 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8272 where
8273 <___T as ::fidl_next::Transport>::SendBuffer:
8274 ::fidl_next::encoder::InternalHandleEncoder,
8275 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8276 {
8277 self.open_exposed_dir_with(crate::generic::ControllerOpenExposedDirRequest {
8278 exposed_dir,
8279 })
8280 }
8281
8282 #[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"]
8283 pub fn open_exposed_dir_with<___R>(
8284 &self,
8285 request: ___R,
8286 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8287 where
8288 ___R: ::fidl_next::Encode<
8289 crate::wire::ControllerOpenExposedDirRequest,
8290 <___T as ::fidl_next::Transport>::SendBuffer,
8291 >,
8292 {
8293 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8294 2683208291886099860,
8295 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
8296 request,
8297 ))
8298 }
8299
8300 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8301 pub fn get_exposed_dictionary(
8302 &self,
8303 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExposedDictionary, ___T> {
8304 ::fidl_next::TwoWayFuture::from_untyped(
8305 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8306 9099583788120940443,
8307 <super::GetExposedDictionary as ::fidl_next::Method>::FLEXIBILITY,
8308 (),
8309 ),
8310 )
8311 }
8312
8313 #[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"]
8314 pub fn get_output_dictionary(
8315 &self,
8316 ) -> ::fidl_next::TwoWayFuture<'_, super::GetOutputDictionary, ___T> {
8317 ::fidl_next::TwoWayFuture::from_untyped(
8318 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8319 4182795765624263201,
8320 <super::GetOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
8321 (),
8322 ),
8323 )
8324 }
8325
8326 #[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"]
8327 pub fn destroy(&self) -> ::fidl_next::TwoWayFuture<'_, super::Destroy, ___T> {
8328 ::fidl_next::TwoWayFuture::from_untyped(
8329 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8330 8381937394141370177,
8331 <super::Destroy as ::fidl_next::Method>::FLEXIBILITY,
8332 (),
8333 ),
8334 )
8335 }
8336 }
8337
8338 #[repr(transparent)]
8340 pub struct ControllerServer<___T: ::fidl_next::Transport> {
8341 server: ::fidl_next::protocol::Server<___T>,
8342 }
8343
8344 impl<___T> ControllerServer<___T> where ___T: ::fidl_next::Transport {}
8345 }
8346}
8347
8348#[diagnostic::on_unimplemented(
8349 note = "If {Self} implements the non-local ControllerClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
8350)]
8351
8352pub trait ControllerLocalClientHandler<
8356 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8357 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8358>
8359{
8360 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8361 ::core::future::ready(())
8362 }
8363}
8364
8365impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Controller
8366where
8367 ___H: ControllerLocalClientHandler<___T>,
8368 ___T: ::fidl_next::Transport,
8369{
8370 async fn on_event(
8371 handler: &mut ___H,
8372 mut message: ::fidl_next::Message<___T>,
8373 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8374 match *message.header().ordinal {
8375 ordinal => {
8376 handler.on_unknown_interaction(ordinal).await;
8377 if ::core::matches!(
8378 message.header().flexibility(),
8379 ::fidl_next::protocol::Flexibility::Strict
8380 ) {
8381 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8382 } else {
8383 Ok(())
8384 }
8385 }
8386 }
8387 }
8388}
8389
8390#[diagnostic::on_unimplemented(
8391 note = "If {Self} implements the non-local ControllerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
8392)]
8393
8394pub trait ControllerLocalServerHandler<
8398 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8399 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8400>
8401{
8402 #[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"]
8403 fn start(
8404 &mut self,
8405
8406 request: ::fidl_next::Request<controller::Start, ___T>,
8407
8408 responder: ::fidl_next::Responder<controller::Start, ___T>,
8409 ) -> impl ::core::future::Future<Output = ()>;
8410
8411 #[doc = " Returns true if this instance is currently running.\n"]
8412 fn is_started(
8413 &mut self,
8414
8415 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8416 ) -> impl ::core::future::Future<Output = ()>;
8417
8418 #[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"]
8419 fn open_exposed_dir(
8420 &mut self,
8421
8422 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8423
8424 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8425 ) -> impl ::core::future::Future<Output = ()>;
8426
8427 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8428 fn get_exposed_dictionary(
8429 &mut self,
8430
8431 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8432 ) -> impl ::core::future::Future<Output = ()>;
8433
8434 #[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"]
8435 fn get_output_dictionary(
8436 &mut self,
8437
8438 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8439 ) -> impl ::core::future::Future<Output = ()>;
8440
8441 #[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"]
8442 fn destroy(
8443 &mut self,
8444
8445 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8446 ) -> impl ::core::future::Future<Output = ()>;
8447
8448 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
8449 ::core::future::ready(())
8450 }
8451}
8452
8453impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Controller
8454where
8455 ___H: ControllerLocalServerHandler<___T>,
8456 ___T: ::fidl_next::Transport,
8457 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8458 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8459 Constraint = (),
8460 >,
8461 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8462 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8463 Constraint = (),
8464 >,
8465{
8466 async fn on_one_way(
8467 handler: &mut ___H,
8468 mut message: ::fidl_next::Message<___T>,
8469 ) -> ::core::result::Result<
8470 (),
8471 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8472 > {
8473 match *message.header().ordinal {
8474 ordinal => {
8475 handler.on_unknown_interaction(ordinal).await;
8476 if ::core::matches!(
8477 message.header().flexibility(),
8478 ::fidl_next::protocol::Flexibility::Strict
8479 ) {
8480 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8481 } else {
8482 Ok(())
8483 }
8484 }
8485 }
8486 }
8487
8488 async fn on_two_way(
8489 handler: &mut ___H,
8490 mut message: ::fidl_next::Message<___T>,
8491 responder: ::fidl_next::protocol::Responder<___T>,
8492 ) -> ::core::result::Result<
8493 (),
8494 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8495 > {
8496 match *message.header().ordinal {
8497 7532130149195770565 => {
8498 let responder = ::fidl_next::Responder::from_untyped(responder);
8499
8500 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8501 Ok(decoded) => {
8502 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8503 Ok(())
8504 }
8505 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8506 ordinal: 7532130149195770565,
8507 error,
8508 }),
8509 }
8510 }
8511
8512 2402079833990398915 => {
8513 let responder = ::fidl_next::Responder::from_untyped(responder);
8514
8515 handler.is_started(responder).await;
8516 Ok(())
8517 }
8518
8519 2683208291886099860 => {
8520 let responder = ::fidl_next::Responder::from_untyped(responder);
8521
8522 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8523 Ok(decoded) => {
8524 handler
8525 .open_exposed_dir(
8526 ::fidl_next::Request::from_decoded(decoded),
8527 responder,
8528 )
8529 .await;
8530 Ok(())
8531 }
8532 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8533 ordinal: 2683208291886099860,
8534 error,
8535 }),
8536 }
8537 }
8538
8539 9099583788120940443 => {
8540 let responder = ::fidl_next::Responder::from_untyped(responder);
8541
8542 handler.get_exposed_dictionary(responder).await;
8543 Ok(())
8544 }
8545
8546 4182795765624263201 => {
8547 let responder = ::fidl_next::Responder::from_untyped(responder);
8548
8549 handler.get_output_dictionary(responder).await;
8550 Ok(())
8551 }
8552
8553 8381937394141370177 => {
8554 let responder = ::fidl_next::Responder::from_untyped(responder);
8555
8556 handler.destroy(responder).await;
8557 Ok(())
8558 }
8559
8560 ordinal => {
8561 handler.on_unknown_interaction(ordinal).await;
8562 if ::core::matches!(
8563 message.header().flexibility(),
8564 ::fidl_next::protocol::Flexibility::Strict
8565 ) {
8566 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8567 } else {
8568 responder
8569 .respond_framework_error(
8570 ordinal,
8571 ::fidl_next::FrameworkError::UnknownMethod,
8572 )
8573 .expect("encoding a framework error should never fail")
8574 .await?;
8575 Ok(())
8576 }
8577 }
8578 }
8579 }
8580}
8581
8582pub trait ControllerClientHandler<
8586 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8587 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8588>
8589{
8590 fn on_unknown_interaction(
8591 &mut self,
8592 ordinal: u64,
8593 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8594 ::core::future::ready(())
8595 }
8596}
8597
8598impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Controller
8599where
8600 ___H: ControllerClientHandler<___T> + ::core::marker::Send,
8601 ___T: ::fidl_next::Transport,
8602{
8603 async fn on_event(
8604 handler: &mut ___H,
8605 mut message: ::fidl_next::Message<___T>,
8606 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8607 match *message.header().ordinal {
8608 ordinal => {
8609 handler.on_unknown_interaction(ordinal).await;
8610 if ::core::matches!(
8611 message.header().flexibility(),
8612 ::fidl_next::protocol::Flexibility::Strict
8613 ) {
8614 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8615 } else {
8616 Ok(())
8617 }
8618 }
8619 }
8620 }
8621}
8622
8623pub trait ControllerServerHandler<
8627 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8628 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8629>
8630{
8631 #[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"]
8632 fn start(
8633 &mut self,
8634
8635 request: ::fidl_next::Request<controller::Start, ___T>,
8636
8637 responder: ::fidl_next::Responder<controller::Start, ___T>,
8638 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8639
8640 #[doc = " Returns true if this instance is currently running.\n"]
8641 fn is_started(
8642 &mut self,
8643
8644 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8645 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8646
8647 #[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"]
8648 fn open_exposed_dir(
8649 &mut self,
8650
8651 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8652
8653 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8654 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8655
8656 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8657 fn get_exposed_dictionary(
8658 &mut self,
8659
8660 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8661 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8662
8663 #[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"]
8664 fn get_output_dictionary(
8665 &mut self,
8666
8667 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8668 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8669
8670 #[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"]
8671 fn destroy(
8672 &mut self,
8673
8674 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8675 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8676
8677 fn on_unknown_interaction(
8678 &mut self,
8679 ordinal: u64,
8680 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8681 ::core::future::ready(())
8682 }
8683}
8684
8685impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Controller
8686where
8687 ___H: ControllerServerHandler<___T> + ::core::marker::Send,
8688 ___T: ::fidl_next::Transport,
8689 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8690 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8691 Constraint = (),
8692 >,
8693 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8694 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8695 Constraint = (),
8696 >,
8697{
8698 async fn on_one_way(
8699 handler: &mut ___H,
8700 mut message: ::fidl_next::Message<___T>,
8701 ) -> ::core::result::Result<
8702 (),
8703 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8704 > {
8705 match *message.header().ordinal {
8706 ordinal => {
8707 handler.on_unknown_interaction(ordinal).await;
8708 if ::core::matches!(
8709 message.header().flexibility(),
8710 ::fidl_next::protocol::Flexibility::Strict
8711 ) {
8712 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8713 } else {
8714 Ok(())
8715 }
8716 }
8717 }
8718 }
8719
8720 async fn on_two_way(
8721 handler: &mut ___H,
8722 mut message: ::fidl_next::Message<___T>,
8723 responder: ::fidl_next::protocol::Responder<___T>,
8724 ) -> ::core::result::Result<
8725 (),
8726 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8727 > {
8728 match *message.header().ordinal {
8729 7532130149195770565 => {
8730 let responder = ::fidl_next::Responder::from_untyped(responder);
8731
8732 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8733 Ok(decoded) => {
8734 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8735 Ok(())
8736 }
8737 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8738 ordinal: 7532130149195770565,
8739 error,
8740 }),
8741 }
8742 }
8743
8744 2402079833990398915 => {
8745 let responder = ::fidl_next::Responder::from_untyped(responder);
8746
8747 handler.is_started(responder).await;
8748 Ok(())
8749 }
8750
8751 2683208291886099860 => {
8752 let responder = ::fidl_next::Responder::from_untyped(responder);
8753
8754 match ::fidl_next::AsDecoderExt::into_decoded(message) {
8755 Ok(decoded) => {
8756 handler
8757 .open_exposed_dir(
8758 ::fidl_next::Request::from_decoded(decoded),
8759 responder,
8760 )
8761 .await;
8762 Ok(())
8763 }
8764 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8765 ordinal: 2683208291886099860,
8766 error,
8767 }),
8768 }
8769 }
8770
8771 9099583788120940443 => {
8772 let responder = ::fidl_next::Responder::from_untyped(responder);
8773
8774 handler.get_exposed_dictionary(responder).await;
8775 Ok(())
8776 }
8777
8778 4182795765624263201 => {
8779 let responder = ::fidl_next::Responder::from_untyped(responder);
8780
8781 handler.get_output_dictionary(responder).await;
8782 Ok(())
8783 }
8784
8785 8381937394141370177 => {
8786 let responder = ::fidl_next::Responder::from_untyped(responder);
8787
8788 handler.destroy(responder).await;
8789 Ok(())
8790 }
8791
8792 ordinal => {
8793 handler.on_unknown_interaction(ordinal).await;
8794 if ::core::matches!(
8795 message.header().flexibility(),
8796 ::fidl_next::protocol::Flexibility::Strict
8797 ) {
8798 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8799 } else {
8800 responder
8801 .respond_framework_error(
8802 ordinal,
8803 ::fidl_next::FrameworkError::UnknownMethod,
8804 )
8805 .expect("encoding a framework error should never fail")
8806 .await?;
8807 Ok(())
8808 }
8809 }
8810 }
8811 }
8812}
8813
8814impl<___T> ControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
8815where
8816 ___T: ::fidl_next::Transport,
8817{
8818 async fn on_unknown_interaction(&mut self, _: u64) {}
8819}
8820
8821impl<___H, ___T> ControllerLocalClientHandler<___T> for ::fidl_next::Local<___H>
8822where
8823 ___H: ControllerClientHandler<___T>,
8824 ___T: ::fidl_next::Transport,
8825{
8826 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8827 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8828 }
8829}
8830
8831impl<___H, ___T> ControllerLocalServerHandler<___T> for ::fidl_next::Local<___H>
8832where
8833 ___H: ControllerServerHandler<___T>,
8834 ___T: ::fidl_next::Transport,
8835{
8836 async fn start(
8837 &mut self,
8838
8839 request: ::fidl_next::Request<controller::Start, ___T>,
8840
8841 responder: ::fidl_next::Responder<controller::Start, ___T>,
8842 ) {
8843 ___H::start(&mut self.0, request, responder).await
8844 }
8845
8846 async fn is_started(&mut self, responder: ::fidl_next::Responder<controller::IsStarted, ___T>) {
8847 ___H::is_started(&mut self.0, responder).await
8848 }
8849
8850 async fn open_exposed_dir(
8851 &mut self,
8852
8853 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8854
8855 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8856 ) {
8857 ___H::open_exposed_dir(&mut self.0, request, responder).await
8858 }
8859
8860 async fn get_exposed_dictionary(
8861 &mut self,
8862
8863 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8864 ) {
8865 ___H::get_exposed_dictionary(&mut self.0, responder).await
8866 }
8867
8868 async fn get_output_dictionary(
8869 &mut self,
8870
8871 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8872 ) {
8873 ___H::get_output_dictionary(&mut self.0, responder).await
8874 }
8875
8876 async fn destroy(&mut self, responder: ::fidl_next::Responder<controller::Destroy, ___T>) {
8877 ___H::destroy(&mut self.0, responder).await
8878 }
8879
8880 async fn on_unknown_interaction(&mut self, ordinal: u64) {
8881 ___H::on_unknown_interaction(&mut self.0, ordinal).await
8882 }
8883}
8884
8885#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
8887#[derive(PartialEq, Debug)]
8888pub struct EventStream;
8889
8890impl ::fidl_next::Discoverable for EventStream {
8891 const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
8892}
8893
8894#[cfg(target_os = "fuchsia")]
8895impl ::fidl_next::HasTransport for EventStream {
8896 type Transport = ::fidl_next::fuchsia::zx::Channel;
8897}
8898
8899pub mod event_stream {
8900 pub mod prelude {
8901 pub use crate::{
8902 EventStream, EventStreamClientHandler, EventStreamLocalClientHandler,
8903 EventStreamLocalServerHandler, EventStreamServerHandler, event_stream,
8904 };
8905
8906 pub use crate::natural::EventStreamGetNextResponse;
8907 }
8908
8909 pub struct GetNext;
8910
8911 impl ::fidl_next::Method for GetNext {
8912 const ORDINAL: u64 = 4549982840421936006;
8913 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8914 ::fidl_next::protocol::Flexibility::Strict;
8915
8916 type Protocol = crate::EventStream;
8917
8918 type Request = ::fidl_next::wire::EmptyMessageBody;
8919 }
8920
8921 impl ::fidl_next::TwoWayMethod for GetNext {
8922 type Response = ::fidl_next::wire::Strict<crate::wire::EventStreamGetNextResponse<'static>>;
8923 }
8924
8925 impl<___R> ::fidl_next::Respond<___R> for GetNext {
8926 type Output = ::fidl_next::Strict<crate::generic::EventStreamGetNextResponse<___R>>;
8927
8928 fn respond(response: ___R) -> Self::Output {
8929 ::fidl_next::Strict(crate::generic::EventStreamGetNextResponse { events: response })
8930 }
8931 }
8932
8933 pub struct WaitForReady;
8934
8935 impl ::fidl_next::Method for WaitForReady {
8936 const ORDINAL: u64 = 3545212058508387970;
8937 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8938 ::fidl_next::protocol::Flexibility::Strict;
8939
8940 type Protocol = crate::EventStream;
8941
8942 type Request = ::fidl_next::wire::EmptyMessageBody;
8943 }
8944
8945 impl ::fidl_next::TwoWayMethod for WaitForReady {
8946 type Response = ::fidl_next::wire::Strict<::fidl_next::wire::EmptyMessageBody>;
8947 }
8948
8949 impl<___R> ::fidl_next::Respond<___R> for WaitForReady {
8950 type Output = ::fidl_next::Strict<___R>;
8951
8952 fn respond(response: ___R) -> Self::Output {
8953 ::fidl_next::Strict(response)
8954 }
8955 }
8956
8957 mod ___detail {
8958 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::EventStream
8959 where
8960 ___T: ::fidl_next::Transport,
8961 {
8962 type Client = EventStreamClient<___T>;
8963 type Server = EventStreamServer<___T>;
8964 }
8965
8966 #[repr(transparent)]
8968 pub struct EventStreamClient<___T: ::fidl_next::Transport> {
8969 #[allow(dead_code)]
8970 client: ::fidl_next::protocol::Client<___T>,
8971 }
8972
8973 impl<___T> EventStreamClient<___T>
8974 where
8975 ___T: ::fidl_next::Transport,
8976 {
8977 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
8978 ::fidl_next::TwoWayFuture::from_untyped(
8979 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8980 4549982840421936006,
8981 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
8982 (),
8983 ),
8984 )
8985 }
8986
8987 #[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"]
8988 pub fn wait_for_ready(
8989 &self,
8990 ) -> ::fidl_next::TwoWayFuture<'_, super::WaitForReady, ___T> {
8991 ::fidl_next::TwoWayFuture::from_untyped(
8992 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8993 3545212058508387970,
8994 <super::WaitForReady as ::fidl_next::Method>::FLEXIBILITY,
8995 (),
8996 ),
8997 )
8998 }
8999 }
9000
9001 #[repr(transparent)]
9003 pub struct EventStreamServer<___T: ::fidl_next::Transport> {
9004 server: ::fidl_next::protocol::Server<___T>,
9005 }
9006
9007 impl<___T> EventStreamServer<___T> where ___T: ::fidl_next::Transport {}
9008 }
9009}
9010
9011#[diagnostic::on_unimplemented(
9012 note = "If {Self} implements the non-local EventStreamClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9013)]
9014
9015pub trait EventStreamLocalClientHandler<
9019 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9020 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9021>
9022{
9023}
9024
9025impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for EventStream
9026where
9027 ___H: EventStreamLocalClientHandler<___T>,
9028 ___T: ::fidl_next::Transport,
9029{
9030 async fn on_event(
9031 handler: &mut ___H,
9032 mut message: ::fidl_next::Message<___T>,
9033 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9034 match *message.header().ordinal {
9035 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9036 }
9037 }
9038}
9039
9040#[diagnostic::on_unimplemented(
9041 note = "If {Self} implements the non-local EventStreamServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9042)]
9043
9044pub trait EventStreamLocalServerHandler<
9048 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9049 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9050>
9051{
9052 fn get_next(
9053 &mut self,
9054
9055 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
9056 ) -> impl ::core::future::Future<Output = ()>;
9057
9058 #[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"]
9059 fn wait_for_ready(
9060 &mut self,
9061
9062 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9063 ) -> impl ::core::future::Future<Output = ()>;
9064}
9065
9066impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for EventStream
9067where
9068 ___H: EventStreamLocalServerHandler<___T>,
9069 ___T: ::fidl_next::Transport,
9070{
9071 async fn on_one_way(
9072 handler: &mut ___H,
9073 mut message: ::fidl_next::Message<___T>,
9074 ) -> ::core::result::Result<
9075 (),
9076 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9077 > {
9078 match *message.header().ordinal {
9079 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9080 }
9081 }
9082
9083 async fn on_two_way(
9084 handler: &mut ___H,
9085 mut message: ::fidl_next::Message<___T>,
9086 responder: ::fidl_next::protocol::Responder<___T>,
9087 ) -> ::core::result::Result<
9088 (),
9089 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9090 > {
9091 match *message.header().ordinal {
9092 4549982840421936006 => {
9093 let responder = ::fidl_next::Responder::from_untyped(responder);
9094
9095 handler.get_next(responder).await;
9096 Ok(())
9097 }
9098
9099 3545212058508387970 => {
9100 let responder = ::fidl_next::Responder::from_untyped(responder);
9101
9102 handler.wait_for_ready(responder).await;
9103 Ok(())
9104 }
9105
9106 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9107 }
9108 }
9109}
9110
9111pub trait EventStreamClientHandler<
9115 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9116 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9117>
9118{
9119}
9120
9121impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for EventStream
9122where
9123 ___H: EventStreamClientHandler<___T> + ::core::marker::Send,
9124 ___T: ::fidl_next::Transport,
9125{
9126 async fn on_event(
9127 handler: &mut ___H,
9128 mut message: ::fidl_next::Message<___T>,
9129 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9130 match *message.header().ordinal {
9131 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9132 }
9133 }
9134}
9135
9136pub trait EventStreamServerHandler<
9140 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9141 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9142>
9143{
9144 fn get_next(
9145 &mut self,
9146
9147 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
9148 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9149
9150 #[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"]
9151 fn wait_for_ready(
9152 &mut self,
9153
9154 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9155 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9156}
9157
9158impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for EventStream
9159where
9160 ___H: EventStreamServerHandler<___T> + ::core::marker::Send,
9161 ___T: ::fidl_next::Transport,
9162{
9163 async fn on_one_way(
9164 handler: &mut ___H,
9165 mut message: ::fidl_next::Message<___T>,
9166 ) -> ::core::result::Result<
9167 (),
9168 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9169 > {
9170 match *message.header().ordinal {
9171 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9172 }
9173 }
9174
9175 async fn on_two_way(
9176 handler: &mut ___H,
9177 mut message: ::fidl_next::Message<___T>,
9178 responder: ::fidl_next::protocol::Responder<___T>,
9179 ) -> ::core::result::Result<
9180 (),
9181 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9182 > {
9183 match *message.header().ordinal {
9184 4549982840421936006 => {
9185 let responder = ::fidl_next::Responder::from_untyped(responder);
9186
9187 handler.get_next(responder).await;
9188 Ok(())
9189 }
9190
9191 3545212058508387970 => {
9192 let responder = ::fidl_next::Responder::from_untyped(responder);
9193
9194 handler.wait_for_ready(responder).await;
9195 Ok(())
9196 }
9197
9198 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
9199 }
9200 }
9201}
9202
9203impl<___T> EventStreamClientHandler<___T> for ::fidl_next::IgnoreEvents where
9204 ___T: ::fidl_next::Transport
9205{
9206}
9207
9208impl<___H, ___T> EventStreamLocalClientHandler<___T> for ::fidl_next::Local<___H>
9209where
9210 ___H: EventStreamClientHandler<___T>,
9211 ___T: ::fidl_next::Transport,
9212{
9213}
9214
9215impl<___H, ___T> EventStreamLocalServerHandler<___T> for ::fidl_next::Local<___H>
9216where
9217 ___H: EventStreamServerHandler<___T>,
9218 ___T: ::fidl_next::Transport,
9219{
9220 async fn get_next(&mut self, responder: ::fidl_next::Responder<event_stream::GetNext, ___T>) {
9221 ___H::get_next(&mut self.0, responder).await
9222 }
9223
9224 async fn wait_for_ready(
9225 &mut self,
9226
9227 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
9228 ) {
9229 ___H::wait_for_ready(&mut self.0, responder).await
9230 }
9231}
9232
9233#[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"]
9235#[derive(PartialEq, Debug)]
9236pub struct Introspector;
9237
9238impl ::fidl_next::Discoverable for Introspector {
9239 const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
9240}
9241
9242#[cfg(target_os = "fuchsia")]
9243impl ::fidl_next::HasTransport for Introspector {
9244 type Transport = ::fidl_next::fuchsia::zx::Channel;
9245}
9246
9247pub mod introspector {
9248 pub mod prelude {
9249 pub use crate::{
9250 Introspector, IntrospectorClientHandler, IntrospectorLocalClientHandler,
9251 IntrospectorLocalServerHandler, IntrospectorServerHandler, introspector,
9252 };
9253
9254 pub use crate::natural::Error;
9255
9256 pub use crate::natural::IntrospectorGetMonikerRequest;
9257
9258 pub use crate::natural::IntrospectorGetMonikerResponse;
9259 }
9260
9261 pub struct GetMoniker;
9262
9263 impl ::fidl_next::Method for GetMoniker {
9264 const ORDINAL: u64 = 214344082539672664;
9265 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9266 ::fidl_next::protocol::Flexibility::Flexible;
9267
9268 type Protocol = crate::Introspector;
9269
9270 type Request = crate::wire::IntrospectorGetMonikerRequest;
9271 }
9272
9273 impl ::fidl_next::TwoWayMethod for GetMoniker {
9274 type Response = ::fidl_next::wire::Result<
9275 'static,
9276 crate::wire::IntrospectorGetMonikerResponse<'static>,
9277 crate::wire::Error,
9278 >;
9279 }
9280
9281 impl<___R> ::fidl_next::Respond<___R> for GetMoniker {
9282 type Output = ::core::result::Result<
9283 crate::generic::IntrospectorGetMonikerResponse<___R>,
9284 ::fidl_next::never::Never,
9285 >;
9286
9287 fn respond(response: ___R) -> Self::Output {
9288 ::core::result::Result::Ok(crate::generic::IntrospectorGetMonikerResponse {
9289 moniker: response,
9290 })
9291 }
9292 }
9293
9294 impl<___R> ::fidl_next::RespondErr<___R> for GetMoniker {
9295 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9296
9297 fn respond_err(response: ___R) -> Self::Output {
9298 ::core::result::Result::Err(response)
9299 }
9300 }
9301
9302 mod ___detail {
9303 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Introspector
9304 where
9305 ___T: ::fidl_next::Transport,
9306 {
9307 type Client = IntrospectorClient<___T>;
9308 type Server = IntrospectorServer<___T>;
9309 }
9310
9311 #[repr(transparent)]
9313 pub struct IntrospectorClient<___T: ::fidl_next::Transport> {
9314 #[allow(dead_code)]
9315 client: ::fidl_next::protocol::Client<___T>,
9316 }
9317
9318 impl<___T> IntrospectorClient<___T>
9319 where
9320 ___T: ::fidl_next::Transport,
9321 {
9322 #[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"]
9323 pub fn get_moniker(
9324 &self,
9325
9326 component_instance: impl ::fidl_next::Encode<
9327 ::fidl_next::wire::fuchsia::Event,
9328 <___T as ::fidl_next::Transport>::SendBuffer,
9329 >,
9330 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9331 where
9332 <___T as ::fidl_next::Transport>::SendBuffer:
9333 ::fidl_next::encoder::InternalHandleEncoder,
9334 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9335 {
9336 self.get_moniker_with(crate::generic::IntrospectorGetMonikerRequest {
9337 component_instance,
9338 })
9339 }
9340
9341 #[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"]
9342 pub fn get_moniker_with<___R>(
9343 &self,
9344 request: ___R,
9345 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
9346 where
9347 ___R: ::fidl_next::Encode<
9348 crate::wire::IntrospectorGetMonikerRequest,
9349 <___T as ::fidl_next::Transport>::SendBuffer,
9350 >,
9351 {
9352 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9353 214344082539672664,
9354 <super::GetMoniker as ::fidl_next::Method>::FLEXIBILITY,
9355 request,
9356 ))
9357 }
9358 }
9359
9360 #[repr(transparent)]
9362 pub struct IntrospectorServer<___T: ::fidl_next::Transport> {
9363 server: ::fidl_next::protocol::Server<___T>,
9364 }
9365
9366 impl<___T> IntrospectorServer<___T> where ___T: ::fidl_next::Transport {}
9367 }
9368}
9369
9370#[diagnostic::on_unimplemented(
9371 note = "If {Self} implements the non-local IntrospectorClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9372)]
9373
9374pub trait IntrospectorLocalClientHandler<
9378 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9379 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9380>
9381{
9382 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9383 ::core::future::ready(())
9384 }
9385}
9386
9387impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Introspector
9388where
9389 ___H: IntrospectorLocalClientHandler<___T>,
9390 ___T: ::fidl_next::Transport,
9391{
9392 async fn on_event(
9393 handler: &mut ___H,
9394 mut message: ::fidl_next::Message<___T>,
9395 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9396 match *message.header().ordinal {
9397 ordinal => {
9398 handler.on_unknown_interaction(ordinal).await;
9399 if ::core::matches!(
9400 message.header().flexibility(),
9401 ::fidl_next::protocol::Flexibility::Strict
9402 ) {
9403 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9404 } else {
9405 Ok(())
9406 }
9407 }
9408 }
9409 }
9410}
9411
9412#[diagnostic::on_unimplemented(
9413 note = "If {Self} implements the non-local IntrospectorServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9414)]
9415
9416pub trait IntrospectorLocalServerHandler<
9420 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9421 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9422>
9423{
9424 #[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"]
9425 fn get_moniker(
9426 &mut self,
9427
9428 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9429
9430 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9431 ) -> impl ::core::future::Future<Output = ()>;
9432
9433 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9434 ::core::future::ready(())
9435 }
9436}
9437
9438impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Introspector
9439where
9440 ___H: IntrospectorLocalServerHandler<___T>,
9441 ___T: ::fidl_next::Transport,
9442 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9443 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9444 Constraint = (),
9445 >,
9446{
9447 async fn on_one_way(
9448 handler: &mut ___H,
9449 mut message: ::fidl_next::Message<___T>,
9450 ) -> ::core::result::Result<
9451 (),
9452 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9453 > {
9454 match *message.header().ordinal {
9455 ordinal => {
9456 handler.on_unknown_interaction(ordinal).await;
9457 if ::core::matches!(
9458 message.header().flexibility(),
9459 ::fidl_next::protocol::Flexibility::Strict
9460 ) {
9461 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9462 } else {
9463 Ok(())
9464 }
9465 }
9466 }
9467 }
9468
9469 async fn on_two_way(
9470 handler: &mut ___H,
9471 mut message: ::fidl_next::Message<___T>,
9472 responder: ::fidl_next::protocol::Responder<___T>,
9473 ) -> ::core::result::Result<
9474 (),
9475 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9476 > {
9477 match *message.header().ordinal {
9478 214344082539672664 => {
9479 let responder = ::fidl_next::Responder::from_untyped(responder);
9480
9481 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9482 Ok(decoded) => {
9483 handler
9484 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9485 .await;
9486 Ok(())
9487 }
9488 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9489 ordinal: 214344082539672664,
9490 error,
9491 }),
9492 }
9493 }
9494
9495 ordinal => {
9496 handler.on_unknown_interaction(ordinal).await;
9497 if ::core::matches!(
9498 message.header().flexibility(),
9499 ::fidl_next::protocol::Flexibility::Strict
9500 ) {
9501 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9502 } else {
9503 responder
9504 .respond_framework_error(
9505 ordinal,
9506 ::fidl_next::FrameworkError::UnknownMethod,
9507 )
9508 .expect("encoding a framework error should never fail")
9509 .await?;
9510 Ok(())
9511 }
9512 }
9513 }
9514 }
9515}
9516
9517pub trait IntrospectorClientHandler<
9521 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9522 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9523>
9524{
9525 fn on_unknown_interaction(
9526 &mut self,
9527 ordinal: u64,
9528 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9529 ::core::future::ready(())
9530 }
9531}
9532
9533impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Introspector
9534where
9535 ___H: IntrospectorClientHandler<___T> + ::core::marker::Send,
9536 ___T: ::fidl_next::Transport,
9537{
9538 async fn on_event(
9539 handler: &mut ___H,
9540 mut message: ::fidl_next::Message<___T>,
9541 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9542 match *message.header().ordinal {
9543 ordinal => {
9544 handler.on_unknown_interaction(ordinal).await;
9545 if ::core::matches!(
9546 message.header().flexibility(),
9547 ::fidl_next::protocol::Flexibility::Strict
9548 ) {
9549 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9550 } else {
9551 Ok(())
9552 }
9553 }
9554 }
9555 }
9556}
9557
9558pub trait IntrospectorServerHandler<
9562 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9563 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9564>
9565{
9566 #[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"]
9567 fn get_moniker(
9568 &mut self,
9569
9570 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9571
9572 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9573 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9574
9575 fn on_unknown_interaction(
9576 &mut self,
9577 ordinal: u64,
9578 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9579 ::core::future::ready(())
9580 }
9581}
9582
9583impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Introspector
9584where
9585 ___H: IntrospectorServerHandler<___T> + ::core::marker::Send,
9586 ___T: ::fidl_next::Transport,
9587 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
9588 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9589 Constraint = (),
9590 >,
9591{
9592 async fn on_one_way(
9593 handler: &mut ___H,
9594 mut message: ::fidl_next::Message<___T>,
9595 ) -> ::core::result::Result<
9596 (),
9597 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9598 > {
9599 match *message.header().ordinal {
9600 ordinal => {
9601 handler.on_unknown_interaction(ordinal).await;
9602 if ::core::matches!(
9603 message.header().flexibility(),
9604 ::fidl_next::protocol::Flexibility::Strict
9605 ) {
9606 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9607 } else {
9608 Ok(())
9609 }
9610 }
9611 }
9612 }
9613
9614 async fn on_two_way(
9615 handler: &mut ___H,
9616 mut message: ::fidl_next::Message<___T>,
9617 responder: ::fidl_next::protocol::Responder<___T>,
9618 ) -> ::core::result::Result<
9619 (),
9620 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9621 > {
9622 match *message.header().ordinal {
9623 214344082539672664 => {
9624 let responder = ::fidl_next::Responder::from_untyped(responder);
9625
9626 match ::fidl_next::AsDecoderExt::into_decoded(message) {
9627 Ok(decoded) => {
9628 handler
9629 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
9630 .await;
9631 Ok(())
9632 }
9633 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9634 ordinal: 214344082539672664,
9635 error,
9636 }),
9637 }
9638 }
9639
9640 ordinal => {
9641 handler.on_unknown_interaction(ordinal).await;
9642 if ::core::matches!(
9643 message.header().flexibility(),
9644 ::fidl_next::protocol::Flexibility::Strict
9645 ) {
9646 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9647 } else {
9648 responder
9649 .respond_framework_error(
9650 ordinal,
9651 ::fidl_next::FrameworkError::UnknownMethod,
9652 )
9653 .expect("encoding a framework error should never fail")
9654 .await?;
9655 Ok(())
9656 }
9657 }
9658 }
9659 }
9660}
9661
9662impl<___T> IntrospectorClientHandler<___T> for ::fidl_next::IgnoreEvents
9663where
9664 ___T: ::fidl_next::Transport,
9665{
9666 async fn on_unknown_interaction(&mut self, _: u64) {}
9667}
9668
9669impl<___H, ___T> IntrospectorLocalClientHandler<___T> for ::fidl_next::Local<___H>
9670where
9671 ___H: IntrospectorClientHandler<___T>,
9672 ___T: ::fidl_next::Transport,
9673{
9674 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9675 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9676 }
9677}
9678
9679impl<___H, ___T> IntrospectorLocalServerHandler<___T> for ::fidl_next::Local<___H>
9680where
9681 ___H: IntrospectorServerHandler<___T>,
9682 ___T: ::fidl_next::Transport,
9683{
9684 async fn get_moniker(
9685 &mut self,
9686
9687 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
9688
9689 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
9690 ) {
9691 ___H::get_moniker(&mut self.0, request, responder).await
9692 }
9693
9694 async fn on_unknown_interaction(&mut self, ordinal: u64) {
9695 ___H::on_unknown_interaction(&mut self.0, ordinal).await
9696 }
9697}
9698
9699#[doc = " Protocol for performing namespace operations.\n"]
9701#[derive(PartialEq, Debug)]
9702pub struct Namespace;
9703
9704impl ::fidl_next::Discoverable for Namespace {
9705 const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
9706}
9707
9708#[cfg(target_os = "fuchsia")]
9709impl ::fidl_next::HasTransport for Namespace {
9710 type Transport = ::fidl_next::fuchsia::zx::Channel;
9711}
9712
9713pub mod namespace {
9714 pub mod prelude {
9715 pub use crate::{
9716 Namespace, NamespaceClientHandler, NamespaceLocalClientHandler,
9717 NamespaceLocalServerHandler, NamespaceServerHandler, namespace,
9718 };
9719
9720 pub use crate::natural::NamespaceCreate2Request;
9721
9722 pub use crate::natural::NamespaceCreateRequest;
9723
9724 pub use crate::natural::NamespaceError;
9725
9726 pub use crate::natural::NamespaceCreate2Response;
9727
9728 pub use crate::natural::NamespaceCreateResponse;
9729 }
9730
9731 pub struct Create;
9732
9733 impl ::fidl_next::Method for Create {
9734 const ORDINAL: u64 = 4839678630846501113;
9735 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9736 ::fidl_next::protocol::Flexibility::Flexible;
9737
9738 type Protocol = crate::Namespace;
9739
9740 type Request = crate::wire::NamespaceCreateRequest<'static>;
9741 }
9742
9743 impl ::fidl_next::TwoWayMethod for Create {
9744 type Response = ::fidl_next::wire::Result<
9745 'static,
9746 crate::wire::NamespaceCreateResponse<'static>,
9747 crate::wire::NamespaceError,
9748 >;
9749 }
9750
9751 impl<___R> ::fidl_next::Respond<___R> for Create {
9752 type Output = ::core::result::Result<
9753 crate::generic::NamespaceCreateResponse<___R>,
9754 ::fidl_next::never::Never,
9755 >;
9756
9757 fn respond(response: ___R) -> Self::Output {
9758 ::core::result::Result::Ok(crate::generic::NamespaceCreateResponse {
9759 entries: response,
9760 })
9761 }
9762 }
9763
9764 impl<___R> ::fidl_next::RespondErr<___R> for Create {
9765 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9766
9767 fn respond_err(response: ___R) -> Self::Output {
9768 ::core::result::Result::Err(response)
9769 }
9770 }
9771
9772 pub struct Create2;
9773
9774 impl ::fidl_next::Method for Create2 {
9775 const ORDINAL: u64 = 7375388463768777553;
9776 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9777 ::fidl_next::protocol::Flexibility::Flexible;
9778
9779 type Protocol = crate::Namespace;
9780
9781 type Request = crate::wire::NamespaceCreate2Request<'static>;
9782 }
9783
9784 impl ::fidl_next::TwoWayMethod for Create2 {
9785 type Response = ::fidl_next::wire::Result<
9786 'static,
9787 crate::wire::NamespaceCreate2Response<'static>,
9788 crate::wire::NamespaceError,
9789 >;
9790 }
9791
9792 impl<___R> ::fidl_next::Respond<___R> for Create2 {
9793 type Output = ::core::result::Result<
9794 crate::generic::NamespaceCreate2Response<___R>,
9795 ::fidl_next::never::Never,
9796 >;
9797
9798 fn respond(response: ___R) -> Self::Output {
9799 ::core::result::Result::Ok(crate::generic::NamespaceCreate2Response {
9800 entries: response,
9801 })
9802 }
9803 }
9804
9805 impl<___R> ::fidl_next::RespondErr<___R> for Create2 {
9806 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
9807
9808 fn respond_err(response: ___R) -> Self::Output {
9809 ::core::result::Result::Err(response)
9810 }
9811 }
9812
9813 mod ___detail {
9814 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Namespace
9815 where
9816 ___T: ::fidl_next::Transport,
9817 {
9818 type Client = NamespaceClient<___T>;
9819 type Server = NamespaceServer<___T>;
9820 }
9821
9822 #[repr(transparent)]
9824 pub struct NamespaceClient<___T: ::fidl_next::Transport> {
9825 #[allow(dead_code)]
9826 client: ::fidl_next::protocol::Client<___T>,
9827 }
9828
9829 impl<___T> NamespaceClient<___T>
9830 where
9831 ___T: ::fidl_next::Transport,
9832 {
9833 pub fn create(
9834 &self,
9835
9836 entries: impl ::fidl_next::Encode<
9837 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
9838 <___T as ::fidl_next::Transport>::SendBuffer,
9839 >,
9840 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9841 where
9842 <___T as ::fidl_next::Transport>::SendBuffer:
9843 ::fidl_next::encoder::InternalHandleEncoder,
9844 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9845 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9846 {
9847 self.create_with(crate::generic::NamespaceCreateRequest { entries })
9848 }
9849
9850 pub fn create_with<___R>(
9851 &self,
9852 request: ___R,
9853 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9854 where
9855 ___R: ::fidl_next::Encode<
9856 crate::wire::NamespaceCreateRequest<'static>,
9857 <___T as ::fidl_next::Transport>::SendBuffer,
9858 >,
9859 {
9860 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9861 4839678630846501113,
9862 <super::Create as ::fidl_next::Method>::FLEXIBILITY,
9863 request,
9864 ))
9865 }
9866
9867 pub fn create2(
9868 &self,
9869
9870 entries: impl ::fidl_next::Encode<
9871 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
9872 <___T as ::fidl_next::Transport>::SendBuffer,
9873 >,
9874 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9875 where
9876 <___T as ::fidl_next::Transport>::SendBuffer:
9877 ::fidl_next::encoder::InternalHandleEncoder,
9878 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9879 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9880 {
9881 self.create2_with(crate::generic::NamespaceCreate2Request { entries })
9882 }
9883
9884 pub fn create2_with<___R>(
9885 &self,
9886 request: ___R,
9887 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9888 where
9889 ___R: ::fidl_next::Encode<
9890 crate::wire::NamespaceCreate2Request<'static>,
9891 <___T as ::fidl_next::Transport>::SendBuffer,
9892 >,
9893 {
9894 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9895 7375388463768777553,
9896 <super::Create2 as ::fidl_next::Method>::FLEXIBILITY,
9897 request,
9898 ))
9899 }
9900 }
9901
9902 #[repr(transparent)]
9904 pub struct NamespaceServer<___T: ::fidl_next::Transport> {
9905 server: ::fidl_next::protocol::Server<___T>,
9906 }
9907
9908 impl<___T> NamespaceServer<___T> where ___T: ::fidl_next::Transport {}
9909 }
9910}
9911
9912#[diagnostic::on_unimplemented(
9913 note = "If {Self} implements the non-local NamespaceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
9914)]
9915
9916pub trait NamespaceLocalClientHandler<
9920 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9921 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9922>
9923{
9924 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9925 ::core::future::ready(())
9926 }
9927}
9928
9929impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Namespace
9930where
9931 ___H: NamespaceLocalClientHandler<___T>,
9932 ___T: ::fidl_next::Transport,
9933{
9934 async fn on_event(
9935 handler: &mut ___H,
9936 mut message: ::fidl_next::Message<___T>,
9937 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9938 match *message.header().ordinal {
9939 ordinal => {
9940 handler.on_unknown_interaction(ordinal).await;
9941 if ::core::matches!(
9942 message.header().flexibility(),
9943 ::fidl_next::protocol::Flexibility::Strict
9944 ) {
9945 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9946 } else {
9947 Ok(())
9948 }
9949 }
9950 }
9951 }
9952}
9953
9954#[diagnostic::on_unimplemented(
9955 note = "If {Self} implements the non-local NamespaceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
9956)]
9957
9958pub trait NamespaceLocalServerHandler<
9962 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9963 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9964>
9965{
9966 fn create(
9967 &mut self,
9968
9969 request: ::fidl_next::Request<namespace::Create, ___T>,
9970
9971 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9972 ) -> impl ::core::future::Future<Output = ()>;
9973
9974 fn create2(
9975 &mut self,
9976
9977 request: ::fidl_next::Request<namespace::Create2, ___T>,
9978
9979 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9980 ) -> impl ::core::future::Future<Output = ()>;
9981
9982 fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
9983 ::core::future::ready(())
9984 }
9985}
9986
9987impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Namespace
9988where
9989 ___H: NamespaceLocalServerHandler<___T>,
9990 ___T: ::fidl_next::Transport,
9991 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9992 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9993 Constraint = (),
9994 >,
9995 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9996 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9997 Constraint = (),
9998 >,
9999{
10000 async fn on_one_way(
10001 handler: &mut ___H,
10002 mut message: ::fidl_next::Message<___T>,
10003 ) -> ::core::result::Result<
10004 (),
10005 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10006 > {
10007 match *message.header().ordinal {
10008 ordinal => {
10009 handler.on_unknown_interaction(ordinal).await;
10010 if ::core::matches!(
10011 message.header().flexibility(),
10012 ::fidl_next::protocol::Flexibility::Strict
10013 ) {
10014 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10015 } else {
10016 Ok(())
10017 }
10018 }
10019 }
10020 }
10021
10022 async fn on_two_way(
10023 handler: &mut ___H,
10024 mut message: ::fidl_next::Message<___T>,
10025 responder: ::fidl_next::protocol::Responder<___T>,
10026 ) -> ::core::result::Result<
10027 (),
10028 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10029 > {
10030 match *message.header().ordinal {
10031 4839678630846501113 => {
10032 let responder = ::fidl_next::Responder::from_untyped(responder);
10033
10034 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10035 Ok(decoded) => {
10036 handler
10037 .create(::fidl_next::Request::from_decoded(decoded), responder)
10038 .await;
10039 Ok(())
10040 }
10041 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10042 ordinal: 4839678630846501113,
10043 error,
10044 }),
10045 }
10046 }
10047
10048 7375388463768777553 => {
10049 let responder = ::fidl_next::Responder::from_untyped(responder);
10050
10051 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10052 Ok(decoded) => {
10053 handler
10054 .create2(::fidl_next::Request::from_decoded(decoded), responder)
10055 .await;
10056 Ok(())
10057 }
10058 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10059 ordinal: 7375388463768777553,
10060 error,
10061 }),
10062 }
10063 }
10064
10065 ordinal => {
10066 handler.on_unknown_interaction(ordinal).await;
10067 if ::core::matches!(
10068 message.header().flexibility(),
10069 ::fidl_next::protocol::Flexibility::Strict
10070 ) {
10071 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10072 } else {
10073 responder
10074 .respond_framework_error(
10075 ordinal,
10076 ::fidl_next::FrameworkError::UnknownMethod,
10077 )
10078 .expect("encoding a framework error should never fail")
10079 .await?;
10080 Ok(())
10081 }
10082 }
10083 }
10084 }
10085}
10086
10087pub trait NamespaceClientHandler<
10091 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10092 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10093>
10094{
10095 fn on_unknown_interaction(
10096 &mut self,
10097 ordinal: u64,
10098 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10099 ::core::future::ready(())
10100 }
10101}
10102
10103impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Namespace
10104where
10105 ___H: NamespaceClientHandler<___T> + ::core::marker::Send,
10106 ___T: ::fidl_next::Transport,
10107{
10108 async fn on_event(
10109 handler: &mut ___H,
10110 mut message: ::fidl_next::Message<___T>,
10111 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10112 match *message.header().ordinal {
10113 ordinal => {
10114 handler.on_unknown_interaction(ordinal).await;
10115 if ::core::matches!(
10116 message.header().flexibility(),
10117 ::fidl_next::protocol::Flexibility::Strict
10118 ) {
10119 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10120 } else {
10121 Ok(())
10122 }
10123 }
10124 }
10125 }
10126}
10127
10128pub trait NamespaceServerHandler<
10132 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10133 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10134>
10135{
10136 fn create(
10137 &mut self,
10138
10139 request: ::fidl_next::Request<namespace::Create, ___T>,
10140
10141 responder: ::fidl_next::Responder<namespace::Create, ___T>,
10142 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10143
10144 fn create2(
10145 &mut self,
10146
10147 request: ::fidl_next::Request<namespace::Create2, ___T>,
10148
10149 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
10150 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10151
10152 fn on_unknown_interaction(
10153 &mut self,
10154 ordinal: u64,
10155 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
10156 ::core::future::ready(())
10157 }
10158}
10159
10160impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Namespace
10161where
10162 ___H: NamespaceServerHandler<___T> + ::core::marker::Send,
10163 ___T: ::fidl_next::Transport,
10164 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
10165 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10166 Constraint = (),
10167 >,
10168 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
10169 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10170 Constraint = (),
10171 >,
10172{
10173 async fn on_one_way(
10174 handler: &mut ___H,
10175 mut message: ::fidl_next::Message<___T>,
10176 ) -> ::core::result::Result<
10177 (),
10178 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10179 > {
10180 match *message.header().ordinal {
10181 ordinal => {
10182 handler.on_unknown_interaction(ordinal).await;
10183 if ::core::matches!(
10184 message.header().flexibility(),
10185 ::fidl_next::protocol::Flexibility::Strict
10186 ) {
10187 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10188 } else {
10189 Ok(())
10190 }
10191 }
10192 }
10193 }
10194
10195 async fn on_two_way(
10196 handler: &mut ___H,
10197 mut message: ::fidl_next::Message<___T>,
10198 responder: ::fidl_next::protocol::Responder<___T>,
10199 ) -> ::core::result::Result<
10200 (),
10201 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10202 > {
10203 match *message.header().ordinal {
10204 4839678630846501113 => {
10205 let responder = ::fidl_next::Responder::from_untyped(responder);
10206
10207 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10208 Ok(decoded) => {
10209 handler
10210 .create(::fidl_next::Request::from_decoded(decoded), responder)
10211 .await;
10212 Ok(())
10213 }
10214 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10215 ordinal: 4839678630846501113,
10216 error,
10217 }),
10218 }
10219 }
10220
10221 7375388463768777553 => {
10222 let responder = ::fidl_next::Responder::from_untyped(responder);
10223
10224 match ::fidl_next::AsDecoderExt::into_decoded(message) {
10225 Ok(decoded) => {
10226 handler
10227 .create2(::fidl_next::Request::from_decoded(decoded), responder)
10228 .await;
10229 Ok(())
10230 }
10231 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10232 ordinal: 7375388463768777553,
10233 error,
10234 }),
10235 }
10236 }
10237
10238 ordinal => {
10239 handler.on_unknown_interaction(ordinal).await;
10240 if ::core::matches!(
10241 message.header().flexibility(),
10242 ::fidl_next::protocol::Flexibility::Strict
10243 ) {
10244 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
10245 } else {
10246 responder
10247 .respond_framework_error(
10248 ordinal,
10249 ::fidl_next::FrameworkError::UnknownMethod,
10250 )
10251 .expect("encoding a framework error should never fail")
10252 .await?;
10253 Ok(())
10254 }
10255 }
10256 }
10257 }
10258}
10259
10260impl<___T> NamespaceClientHandler<___T> for ::fidl_next::IgnoreEvents
10261where
10262 ___T: ::fidl_next::Transport,
10263{
10264 async fn on_unknown_interaction(&mut self, _: u64) {}
10265}
10266
10267impl<___H, ___T> NamespaceLocalClientHandler<___T> for ::fidl_next::Local<___H>
10268where
10269 ___H: NamespaceClientHandler<___T>,
10270 ___T: ::fidl_next::Transport,
10271{
10272 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10273 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10274 }
10275}
10276
10277impl<___H, ___T> NamespaceLocalServerHandler<___T> for ::fidl_next::Local<___H>
10278where
10279 ___H: NamespaceServerHandler<___T>,
10280 ___T: ::fidl_next::Transport,
10281{
10282 async fn create(
10283 &mut self,
10284
10285 request: ::fidl_next::Request<namespace::Create, ___T>,
10286
10287 responder: ::fidl_next::Responder<namespace::Create, ___T>,
10288 ) {
10289 ___H::create(&mut self.0, request, responder).await
10290 }
10291
10292 async fn create2(
10293 &mut self,
10294
10295 request: ::fidl_next::Request<namespace::Create2, ___T>,
10296
10297 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
10298 ) {
10299 ___H::create2(&mut self.0, request, responder).await
10300 }
10301
10302 async fn on_unknown_interaction(&mut self, ordinal: u64) {
10303 ___H::on_unknown_interaction(&mut self.0, ordinal).await
10304 }
10305}
10306
10307#[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"]
10309#[derive(PartialEq, Debug)]
10310pub struct Realm;
10311
10312impl ::fidl_next::Discoverable for Realm {
10313 const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
10314}
10315
10316#[cfg(target_os = "fuchsia")]
10317impl ::fidl_next::HasTransport for Realm {
10318 type Transport = ::fidl_next::fuchsia::zx::Channel;
10319}
10320
10321pub mod realm {
10322 pub mod prelude {
10323 pub use crate::{
10324 Realm, RealmClientHandler, RealmLocalClientHandler, RealmLocalServerHandler,
10325 RealmServerHandler, realm,
10326 };
10327
10328 pub use crate::natural::Error;
10329
10330 pub use crate::natural::RealmCreateChildRequest;
10331
10332 pub use crate::natural::RealmDestroyChildRequest;
10333
10334 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
10335
10336 pub use crate::natural::RealmGetChildOutputDictionaryRequest;
10337
10338 pub use crate::natural::RealmListChildrenRequest;
10339
10340 pub use crate::natural::RealmOpenControllerRequest;
10341
10342 pub use crate::natural::RealmOpenExposedDirRequest;
10343
10344 pub use crate::natural::RealmCreateChildResponse;
10345
10346 pub use crate::natural::RealmDestroyChildResponse;
10347
10348 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
10349
10350 pub use crate::natural::RealmGetChildOutputDictionaryResponse;
10351
10352 pub use crate::natural::RealmGetResolvedInfoResponse;
10353
10354 pub use crate::natural::RealmListChildrenResponse;
10355
10356 pub use crate::natural::RealmOpenControllerResponse;
10357
10358 pub use crate::natural::RealmOpenExposedDirResponse;
10359 }
10360
10361 pub struct OpenController;
10362
10363 impl ::fidl_next::Method for OpenController {
10364 const ORDINAL: u64 = 8165227925828473216;
10365 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10366 ::fidl_next::protocol::Flexibility::Strict;
10367
10368 type Protocol = crate::Realm;
10369
10370 type Request = crate::wire::RealmOpenControllerRequest<'static>;
10371 }
10372
10373 impl ::fidl_next::TwoWayMethod for OpenController {
10374 type Response = ::fidl_next::wire::Result<
10375 'static,
10376 crate::wire::RealmOpenControllerResponse,
10377 crate::wire::Error,
10378 >;
10379 }
10380
10381 impl<___R> ::fidl_next::Respond<___R> for OpenController {
10382 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10383
10384 fn respond(response: ___R) -> Self::Output {
10385 ::core::result::Result::Ok(response)
10386 }
10387 }
10388
10389 impl<___R> ::fidl_next::RespondErr<___R> for OpenController {
10390 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10391
10392 fn respond_err(response: ___R) -> Self::Output {
10393 ::core::result::Result::Err(response)
10394 }
10395 }
10396
10397 pub struct OpenExposedDir;
10398
10399 impl ::fidl_next::Method for OpenExposedDir {
10400 const ORDINAL: u64 = 9194435320863127852;
10401 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10402 ::fidl_next::protocol::Flexibility::Strict;
10403
10404 type Protocol = crate::Realm;
10405
10406 type Request = crate::wire::RealmOpenExposedDirRequest<'static>;
10407 }
10408
10409 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
10410 type Response = ::fidl_next::wire::Result<
10411 'static,
10412 crate::wire::RealmOpenExposedDirResponse,
10413 crate::wire::Error,
10414 >;
10415 }
10416
10417 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
10418 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10419
10420 fn respond(response: ___R) -> Self::Output {
10421 ::core::result::Result::Ok(response)
10422 }
10423 }
10424
10425 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
10426 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10427
10428 fn respond_err(response: ___R) -> Self::Output {
10429 ::core::result::Result::Err(response)
10430 }
10431 }
10432
10433 pub struct CreateChild;
10434
10435 impl ::fidl_next::Method for CreateChild {
10436 const ORDINAL: u64 = 4892190024503489888;
10437 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10438 ::fidl_next::protocol::Flexibility::Strict;
10439
10440 type Protocol = crate::Realm;
10441
10442 type Request = crate::wire::RealmCreateChildRequest<'static>;
10443 }
10444
10445 impl ::fidl_next::TwoWayMethod for CreateChild {
10446 type Response = ::fidl_next::wire::Result<
10447 'static,
10448 crate::wire::RealmCreateChildResponse,
10449 crate::wire::Error,
10450 >;
10451 }
10452
10453 impl<___R> ::fidl_next::Respond<___R> for CreateChild {
10454 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10455
10456 fn respond(response: ___R) -> Self::Output {
10457 ::core::result::Result::Ok(response)
10458 }
10459 }
10460
10461 impl<___R> ::fidl_next::RespondErr<___R> for CreateChild {
10462 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10463
10464 fn respond_err(response: ___R) -> Self::Output {
10465 ::core::result::Result::Err(response)
10466 }
10467 }
10468
10469 pub struct DestroyChild;
10470
10471 impl ::fidl_next::Method for DestroyChild {
10472 const ORDINAL: u64 = 8203529889988252194;
10473 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10474 ::fidl_next::protocol::Flexibility::Strict;
10475
10476 type Protocol = crate::Realm;
10477
10478 type Request = crate::wire::RealmDestroyChildRequest<'static>;
10479 }
10480
10481 impl ::fidl_next::TwoWayMethod for DestroyChild {
10482 type Response = ::fidl_next::wire::Result<
10483 'static,
10484 crate::wire::RealmDestroyChildResponse,
10485 crate::wire::Error,
10486 >;
10487 }
10488
10489 impl<___R> ::fidl_next::Respond<___R> for DestroyChild {
10490 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10491
10492 fn respond(response: ___R) -> Self::Output {
10493 ::core::result::Result::Ok(response)
10494 }
10495 }
10496
10497 impl<___R> ::fidl_next::RespondErr<___R> for DestroyChild {
10498 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10499
10500 fn respond_err(response: ___R) -> Self::Output {
10501 ::core::result::Result::Err(response)
10502 }
10503 }
10504
10505 pub struct ListChildren;
10506
10507 impl ::fidl_next::Method for ListChildren {
10508 const ORDINAL: u64 = 7532454435519185057;
10509 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10510 ::fidl_next::protocol::Flexibility::Strict;
10511
10512 type Protocol = crate::Realm;
10513
10514 type Request = crate::wire::RealmListChildrenRequest<'static>;
10515 }
10516
10517 impl ::fidl_next::TwoWayMethod for ListChildren {
10518 type Response = ::fidl_next::wire::Result<
10519 'static,
10520 crate::wire::RealmListChildrenResponse,
10521 crate::wire::Error,
10522 >;
10523 }
10524
10525 impl<___R> ::fidl_next::Respond<___R> for ListChildren {
10526 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
10527
10528 fn respond(response: ___R) -> Self::Output {
10529 ::core::result::Result::Ok(response)
10530 }
10531 }
10532
10533 impl<___R> ::fidl_next::RespondErr<___R> for ListChildren {
10534 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10535
10536 fn respond_err(response: ___R) -> Self::Output {
10537 ::core::result::Result::Err(response)
10538 }
10539 }
10540
10541 pub struct GetResolvedInfo;
10542
10543 impl ::fidl_next::Method for GetResolvedInfo {
10544 const ORDINAL: u64 = 8308987710372188322;
10545 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10546 ::fidl_next::protocol::Flexibility::Strict;
10547
10548 type Protocol = crate::Realm;
10549
10550 type Request = ::fidl_next::wire::EmptyMessageBody;
10551 }
10552
10553 impl ::fidl_next::TwoWayMethod for GetResolvedInfo {
10554 type Response = ::fidl_next::wire::Result<
10555 'static,
10556 crate::wire::RealmGetResolvedInfoResponse<'static>,
10557 crate::wire::Error,
10558 >;
10559 }
10560
10561 impl<___R> ::fidl_next::Respond<___R> for GetResolvedInfo {
10562 type Output = ::core::result::Result<
10563 crate::generic::RealmGetResolvedInfoResponse<___R>,
10564 ::fidl_next::never::Never,
10565 >;
10566
10567 fn respond(response: ___R) -> Self::Output {
10568 ::core::result::Result::Ok(crate::generic::RealmGetResolvedInfoResponse {
10569 resolved_info: response,
10570 })
10571 }
10572 }
10573
10574 impl<___R> ::fidl_next::RespondErr<___R> for GetResolvedInfo {
10575 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10576
10577 fn respond_err(response: ___R) -> Self::Output {
10578 ::core::result::Result::Err(response)
10579 }
10580 }
10581
10582 pub struct GetChildOutputDictionaryDeprecated;
10583
10584 impl ::fidl_next::Method for GetChildOutputDictionaryDeprecated {
10585 const ORDINAL: u64 = 4117516026351534948;
10586 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10587 ::fidl_next::protocol::Flexibility::Strict;
10588
10589 type Protocol = crate::Realm;
10590
10591 type Request = crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>;
10592 }
10593
10594 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionaryDeprecated {
10595 type Response = ::fidl_next::wire::Result<
10596 'static,
10597 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
10598 crate::wire::Error,
10599 >;
10600 }
10601
10602 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionaryDeprecated {
10603 type Output = ::core::result::Result<
10604 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse<___R>,
10605 ::fidl_next::never::Never,
10606 >;
10607
10608 fn respond(response: ___R) -> Self::Output {
10609 ::core::result::Result::Ok(
10610 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse {
10611 dictionary: response,
10612 },
10613 )
10614 }
10615 }
10616
10617 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionaryDeprecated {
10618 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10619
10620 fn respond_err(response: ___R) -> Self::Output {
10621 ::core::result::Result::Err(response)
10622 }
10623 }
10624
10625 pub struct GetChildOutputDictionary;
10626
10627 impl ::fidl_next::Method for GetChildOutputDictionary {
10628 const ORDINAL: u64 = 4781081784078915088;
10629 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10630 ::fidl_next::protocol::Flexibility::Strict;
10631
10632 type Protocol = crate::Realm;
10633
10634 type Request = crate::wire::RealmGetChildOutputDictionaryRequest<'static>;
10635 }
10636
10637 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionary {
10638 type Response = ::fidl_next::wire::Result<
10639 'static,
10640 crate::wire::RealmGetChildOutputDictionaryResponse,
10641 crate::wire::Error,
10642 >;
10643 }
10644
10645 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionary {
10646 type Output = ::core::result::Result<
10647 crate::generic::RealmGetChildOutputDictionaryResponse<___R>,
10648 ::fidl_next::never::Never,
10649 >;
10650
10651 fn respond(response: ___R) -> Self::Output {
10652 ::core::result::Result::Ok(crate::generic::RealmGetChildOutputDictionaryResponse {
10653 dictionary: response,
10654 })
10655 }
10656 }
10657
10658 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionary {
10659 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
10660
10661 fn respond_err(response: ___R) -> Self::Output {
10662 ::core::result::Result::Err(response)
10663 }
10664 }
10665
10666 mod ___detail {
10667 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Realm
10668 where
10669 ___T: ::fidl_next::Transport,
10670 {
10671 type Client = RealmClient<___T>;
10672 type Server = RealmServer<___T>;
10673 }
10674
10675 #[repr(transparent)]
10677 pub struct RealmClient<___T: ::fidl_next::Transport> {
10678 #[allow(dead_code)]
10679 client: ::fidl_next::protocol::Client<___T>,
10680 }
10681
10682 impl<___T> RealmClient<___T>
10683 where
10684 ___T: ::fidl_next::Transport,
10685 {
10686 #[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"]
10687 pub fn open_controller(
10688 &self,
10689
10690 child: impl ::fidl_next::Encode<
10691 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10692 <___T as ::fidl_next::Transport>::SendBuffer,
10693 >,
10694
10695 controller: impl ::fidl_next::Encode<
10696 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
10697 <___T as ::fidl_next::Transport>::SendBuffer,
10698 >,
10699 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10700 where
10701 <___T as ::fidl_next::Transport>::SendBuffer:
10702 ::fidl_next::encoder::InternalHandleEncoder,
10703 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10704 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10705 {
10706 self.open_controller_with(crate::generic::RealmOpenControllerRequest {
10707 child,
10708
10709 controller,
10710 })
10711 }
10712
10713 #[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"]
10714 pub fn open_controller_with<___R>(
10715 &self,
10716 request: ___R,
10717 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
10718 where
10719 ___R: ::fidl_next::Encode<
10720 crate::wire::RealmOpenControllerRequest<'static>,
10721 <___T as ::fidl_next::Transport>::SendBuffer,
10722 >,
10723 {
10724 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10725 8165227925828473216,
10726 <super::OpenController as ::fidl_next::Method>::FLEXIBILITY,
10727 request,
10728 ))
10729 }
10730
10731 #[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"]
10732 pub fn open_exposed_dir(
10733 &self,
10734
10735 child: impl ::fidl_next::Encode<
10736 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10737 <___T as ::fidl_next::Transport>::SendBuffer,
10738 >,
10739
10740 exposed_dir: impl ::fidl_next::Encode<
10741 ::fidl_next::ServerEnd<
10742 ::fidl_next_fuchsia_io::Directory,
10743 ::fidl_next::wire::fuchsia::Channel,
10744 >,
10745 <___T as ::fidl_next::Transport>::SendBuffer,
10746 >,
10747 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10748 where
10749 <___T as ::fidl_next::Transport>::SendBuffer:
10750 ::fidl_next::encoder::InternalHandleEncoder,
10751 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10752 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10753 {
10754 self.open_exposed_dir_with(crate::generic::RealmOpenExposedDirRequest {
10755 child,
10756
10757 exposed_dir,
10758 })
10759 }
10760
10761 #[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"]
10762 pub fn open_exposed_dir_with<___R>(
10763 &self,
10764 request: ___R,
10765 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
10766 where
10767 ___R: ::fidl_next::Encode<
10768 crate::wire::RealmOpenExposedDirRequest<'static>,
10769 <___T as ::fidl_next::Transport>::SendBuffer,
10770 >,
10771 {
10772 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10773 9194435320863127852,
10774 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
10775 request,
10776 ))
10777 }
10778
10779 #[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"]
10780 pub fn create_child(
10781 &self,
10782
10783 collection: impl ::fidl_next::Encode<
10784 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10785 <___T as ::fidl_next::Transport>::SendBuffer,
10786 >,
10787
10788 decl: impl ::fidl_next::Encode<
10789 ::fidl_next_fuchsia_component_decl::wire::Child<'static>,
10790 <___T as ::fidl_next::Transport>::SendBuffer,
10791 >,
10792
10793 args: impl ::fidl_next::Encode<
10794 crate::wire::CreateChildArgs<'static>,
10795 <___T as ::fidl_next::Transport>::SendBuffer,
10796 >,
10797 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10798 where
10799 <___T as ::fidl_next::Transport>::SendBuffer:
10800 ::fidl_next::encoder::InternalHandleEncoder,
10801 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10802 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10803 {
10804 self.create_child_with(crate::generic::RealmCreateChildRequest {
10805 collection,
10806
10807 decl,
10808
10809 args,
10810 })
10811 }
10812
10813 #[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"]
10814 pub fn create_child_with<___R>(
10815 &self,
10816 request: ___R,
10817 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
10818 where
10819 ___R: ::fidl_next::Encode<
10820 crate::wire::RealmCreateChildRequest<'static>,
10821 <___T as ::fidl_next::Transport>::SendBuffer,
10822 >,
10823 {
10824 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10825 4892190024503489888,
10826 <super::CreateChild as ::fidl_next::Method>::FLEXIBILITY,
10827 request,
10828 ))
10829 }
10830
10831 #[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"]
10832 pub fn destroy_child(
10833 &self,
10834
10835 child: impl ::fidl_next::Encode<
10836 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10837 <___T as ::fidl_next::Transport>::SendBuffer,
10838 >,
10839 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10840 where
10841 <___T as ::fidl_next::Transport>::SendBuffer:
10842 ::fidl_next::encoder::InternalHandleEncoder,
10843 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10844 {
10845 self.destroy_child_with(crate::generic::RealmDestroyChildRequest { child })
10846 }
10847
10848 #[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"]
10849 pub fn destroy_child_with<___R>(
10850 &self,
10851 request: ___R,
10852 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
10853 where
10854 ___R: ::fidl_next::Encode<
10855 crate::wire::RealmDestroyChildRequest<'static>,
10856 <___T as ::fidl_next::Transport>::SendBuffer,
10857 >,
10858 {
10859 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10860 8203529889988252194,
10861 <super::DestroyChild as ::fidl_next::Method>::FLEXIBILITY,
10862 request,
10863 ))
10864 }
10865
10866 #[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"]
10867 pub fn list_children(
10868 &self,
10869
10870 collection: impl ::fidl_next::Encode<
10871 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
10872 <___T as ::fidl_next::Transport>::SendBuffer,
10873 >,
10874
10875 iter: impl ::fidl_next::Encode<
10876 ::fidl_next::ServerEnd<
10877 crate::ChildIterator,
10878 ::fidl_next::wire::fuchsia::Channel,
10879 >,
10880 <___T as ::fidl_next::Transport>::SendBuffer,
10881 >,
10882 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10883 where
10884 <___T as ::fidl_next::Transport>::SendBuffer:
10885 ::fidl_next::encoder::InternalHandleEncoder,
10886 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10887 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10888 {
10889 self.list_children_with(crate::generic::RealmListChildrenRequest {
10890 collection,
10891
10892 iter,
10893 })
10894 }
10895
10896 #[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"]
10897 pub fn list_children_with<___R>(
10898 &self,
10899 request: ___R,
10900 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
10901 where
10902 ___R: ::fidl_next::Encode<
10903 crate::wire::RealmListChildrenRequest<'static>,
10904 <___T as ::fidl_next::Transport>::SendBuffer,
10905 >,
10906 {
10907 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10908 7532454435519185057,
10909 <super::ListChildren as ::fidl_next::Method>::FLEXIBILITY,
10910 request,
10911 ))
10912 }
10913
10914 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10915 pub fn get_resolved_info(
10916 &self,
10917 ) -> ::fidl_next::TwoWayFuture<'_, super::GetResolvedInfo, ___T> {
10918 ::fidl_next::TwoWayFuture::from_untyped(
10919 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10920 8308987710372188322,
10921 <super::GetResolvedInfo as ::fidl_next::Method>::FLEXIBILITY,
10922 (),
10923 ),
10924 )
10925 }
10926
10927 pub fn get_child_output_dictionary_deprecated(
10928 &self,
10929
10930 child: impl ::fidl_next::Encode<
10931 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10932 <___T as ::fidl_next::Transport>::SendBuffer,
10933 >,
10934 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10935 where
10936 <___T as ::fidl_next::Transport>::SendBuffer:
10937 ::fidl_next::encoder::InternalHandleEncoder,
10938 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10939 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10940 {
10941 self.get_child_output_dictionary_deprecated_with(
10942 crate::generic::RealmGetChildOutputDictionaryDeprecatedRequest { child },
10943 )
10944 }
10945
10946 pub fn get_child_output_dictionary_deprecated_with<___R>(
10947 &self,
10948 request: ___R,
10949 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
10950 where
10951 ___R: ::fidl_next::Encode<
10952 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
10953 <___T as ::fidl_next::Transport>::SendBuffer,
10954 >,
10955 {
10956 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10957 4117516026351534948,
10958 <super::GetChildOutputDictionaryDeprecated as ::fidl_next::Method>::FLEXIBILITY,
10959 request,
10960 ))
10961 }
10962
10963 #[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"]
10964 pub fn get_child_output_dictionary(
10965 &self,
10966
10967 child: impl ::fidl_next::Encode<
10968 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
10969 <___T as ::fidl_next::Transport>::SendBuffer,
10970 >,
10971 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10972 where
10973 <___T as ::fidl_next::Transport>::SendBuffer:
10974 ::fidl_next::encoder::InternalHandleEncoder,
10975 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10976 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10977 {
10978 self.get_child_output_dictionary_with(
10979 crate::generic::RealmGetChildOutputDictionaryRequest { child },
10980 )
10981 }
10982
10983 #[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"]
10984 pub fn get_child_output_dictionary_with<___R>(
10985 &self,
10986 request: ___R,
10987 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
10988 where
10989 ___R: ::fidl_next::Encode<
10990 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
10991 <___T as ::fidl_next::Transport>::SendBuffer,
10992 >,
10993 {
10994 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10995 4781081784078915088,
10996 <super::GetChildOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
10997 request,
10998 ))
10999 }
11000 }
11001
11002 #[repr(transparent)]
11004 pub struct RealmServer<___T: ::fidl_next::Transport> {
11005 server: ::fidl_next::protocol::Server<___T>,
11006 }
11007
11008 impl<___T> RealmServer<___T> where ___T: ::fidl_next::Transport {}
11009 }
11010}
11011
11012#[diagnostic::on_unimplemented(
11013 note = "If {Self} implements the non-local RealmClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
11014)]
11015
11016pub trait RealmLocalClientHandler<
11020 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11021 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11022>
11023{
11024}
11025
11026impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Realm
11027where
11028 ___H: RealmLocalClientHandler<___T>,
11029 ___T: ::fidl_next::Transport,
11030{
11031 async fn on_event(
11032 handler: &mut ___H,
11033 mut message: ::fidl_next::Message<___T>,
11034 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11035 match *message.header().ordinal {
11036 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11037 }
11038 }
11039}
11040
11041#[diagnostic::on_unimplemented(
11042 note = "If {Self} implements the non-local RealmServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
11043)]
11044
11045pub trait RealmLocalServerHandler<
11049 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11050 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11051>
11052{
11053 #[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"]
11054 fn open_controller(
11055 &mut self,
11056
11057 request: ::fidl_next::Request<realm::OpenController, ___T>,
11058
11059 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11060 ) -> impl ::core::future::Future<Output = ()>;
11061
11062 #[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"]
11063 fn open_exposed_dir(
11064 &mut self,
11065
11066 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11067
11068 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11069 ) -> impl ::core::future::Future<Output = ()>;
11070
11071 #[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"]
11072 fn create_child(
11073 &mut self,
11074
11075 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11076
11077 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11078 ) -> impl ::core::future::Future<Output = ()>;
11079
11080 #[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"]
11081 fn destroy_child(
11082 &mut self,
11083
11084 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11085
11086 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11087 ) -> impl ::core::future::Future<Output = ()>;
11088
11089 #[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"]
11090 fn list_children(
11091 &mut self,
11092
11093 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11094
11095 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11096 ) -> impl ::core::future::Future<Output = ()>;
11097
11098 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11099 fn get_resolved_info(
11100 &mut self,
11101
11102 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11103 ) -> impl ::core::future::Future<Output = ()>;
11104
11105 fn get_child_output_dictionary_deprecated(
11106 &mut self,
11107
11108 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11109
11110 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11111 ) -> impl ::core::future::Future<Output = ()>;
11112
11113 #[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"]
11114 fn get_child_output_dictionary(
11115 &mut self,
11116
11117 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11118
11119 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11120 ) -> impl ::core::future::Future<Output = ()>;
11121}
11122
11123impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Realm
11124where
11125 ___H: RealmLocalServerHandler<___T>,
11126 ___T: ::fidl_next::Transport,
11127 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
11128 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11129 Constraint = (),
11130 >,
11131 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
11132 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11133 Constraint = (),
11134 >,
11135 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
11136 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11137 Constraint = (),
11138 >,
11139 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
11140 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11141 Constraint = (),
11142 >,
11143 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
11144 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11145 Constraint = (),
11146 >,
11147 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
11148 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11149 Constraint = (),
11150 >,
11151 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
11152 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11153 Constraint = (),
11154 >,
11155{
11156 async fn on_one_way(
11157 handler: &mut ___H,
11158 mut message: ::fidl_next::Message<___T>,
11159 ) -> ::core::result::Result<
11160 (),
11161 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11162 > {
11163 match *message.header().ordinal {
11164 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11165 }
11166 }
11167
11168 async fn on_two_way(
11169 handler: &mut ___H,
11170 mut message: ::fidl_next::Message<___T>,
11171 responder: ::fidl_next::protocol::Responder<___T>,
11172 ) -> ::core::result::Result<
11173 (),
11174 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11175 > {
11176 match *message.header().ordinal {
11177 8165227925828473216 => {
11178 let responder = ::fidl_next::Responder::from_untyped(responder);
11179
11180 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11181 Ok(decoded) => {
11182 handler
11183 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11184 .await;
11185 Ok(())
11186 }
11187 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11188 ordinal: 8165227925828473216,
11189 error,
11190 }),
11191 }
11192 }
11193
11194 9194435320863127852 => {
11195 let responder = ::fidl_next::Responder::from_untyped(responder);
11196
11197 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11198 Ok(decoded) => {
11199 handler
11200 .open_exposed_dir(
11201 ::fidl_next::Request::from_decoded(decoded),
11202 responder,
11203 )
11204 .await;
11205 Ok(())
11206 }
11207 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11208 ordinal: 9194435320863127852,
11209 error,
11210 }),
11211 }
11212 }
11213
11214 4892190024503489888 => {
11215 let responder = ::fidl_next::Responder::from_untyped(responder);
11216
11217 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11218 Ok(decoded) => {
11219 handler
11220 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11221 .await;
11222 Ok(())
11223 }
11224 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11225 ordinal: 4892190024503489888,
11226 error,
11227 }),
11228 }
11229 }
11230
11231 8203529889988252194 => {
11232 let responder = ::fidl_next::Responder::from_untyped(responder);
11233
11234 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11235 Ok(decoded) => {
11236 handler
11237 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11238 .await;
11239 Ok(())
11240 }
11241 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11242 ordinal: 8203529889988252194,
11243 error,
11244 }),
11245 }
11246 }
11247
11248 7532454435519185057 => {
11249 let responder = ::fidl_next::Responder::from_untyped(responder);
11250
11251 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11252 Ok(decoded) => {
11253 handler
11254 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11255 .await;
11256 Ok(())
11257 }
11258 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11259 ordinal: 7532454435519185057,
11260 error,
11261 }),
11262 }
11263 }
11264
11265 8308987710372188322 => {
11266 let responder = ::fidl_next::Responder::from_untyped(responder);
11267
11268 handler.get_resolved_info(responder).await;
11269 Ok(())
11270 }
11271
11272 4117516026351534948 => {
11273 let responder = ::fidl_next::Responder::from_untyped(responder);
11274
11275 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11276 Ok(decoded) => {
11277 handler
11278 .get_child_output_dictionary_deprecated(
11279 ::fidl_next::Request::from_decoded(decoded),
11280 responder,
11281 )
11282 .await;
11283 Ok(())
11284 }
11285 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11286 ordinal: 4117516026351534948,
11287 error,
11288 }),
11289 }
11290 }
11291
11292 4781081784078915088 => {
11293 let responder = ::fidl_next::Responder::from_untyped(responder);
11294
11295 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11296 Ok(decoded) => {
11297 handler
11298 .get_child_output_dictionary(
11299 ::fidl_next::Request::from_decoded(decoded),
11300 responder,
11301 )
11302 .await;
11303 Ok(())
11304 }
11305 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11306 ordinal: 4781081784078915088,
11307 error,
11308 }),
11309 }
11310 }
11311
11312 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11313 }
11314 }
11315}
11316
11317pub trait RealmClientHandler<
11321 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11322 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11323>
11324{
11325}
11326
11327impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Realm
11328where
11329 ___H: RealmClientHandler<___T> + ::core::marker::Send,
11330 ___T: ::fidl_next::Transport,
11331{
11332 async fn on_event(
11333 handler: &mut ___H,
11334 mut message: ::fidl_next::Message<___T>,
11335 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
11336 match *message.header().ordinal {
11337 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11338 }
11339 }
11340}
11341
11342pub trait RealmServerHandler<
11346 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
11347 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
11348>
11349{
11350 #[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"]
11351 fn open_controller(
11352 &mut self,
11353
11354 request: ::fidl_next::Request<realm::OpenController, ___T>,
11355
11356 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11357 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11358
11359 #[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"]
11360 fn open_exposed_dir(
11361 &mut self,
11362
11363 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11364
11365 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11366 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11367
11368 #[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"]
11369 fn create_child(
11370 &mut self,
11371
11372 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11373
11374 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11375 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11376
11377 #[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"]
11378 fn destroy_child(
11379 &mut self,
11380
11381 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11382
11383 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11384 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11385
11386 #[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"]
11387 fn list_children(
11388 &mut self,
11389
11390 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11391
11392 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11393 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11394
11395 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
11396 fn get_resolved_info(
11397 &mut self,
11398
11399 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11400 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11401
11402 fn get_child_output_dictionary_deprecated(
11403 &mut self,
11404
11405 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11406
11407 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11408 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11409
11410 #[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"]
11411 fn get_child_output_dictionary(
11412 &mut self,
11413
11414 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11415
11416 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11417 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
11418}
11419
11420impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Realm
11421where
11422 ___H: RealmServerHandler<___T> + ::core::marker::Send,
11423 ___T: ::fidl_next::Transport,
11424 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
11425 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11426 Constraint = (),
11427 >,
11428 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
11429 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11430 Constraint = (),
11431 >,
11432 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
11433 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11434 Constraint = (),
11435 >,
11436 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
11437 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11438 Constraint = (),
11439 >,
11440 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
11441 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11442 Constraint = (),
11443 >,
11444 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
11445 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11446 Constraint = (),
11447 >,
11448 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
11449 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
11450 Constraint = (),
11451 >,
11452{
11453 async fn on_one_way(
11454 handler: &mut ___H,
11455 mut message: ::fidl_next::Message<___T>,
11456 ) -> ::core::result::Result<
11457 (),
11458 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11459 > {
11460 match *message.header().ordinal {
11461 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11462 }
11463 }
11464
11465 async fn on_two_way(
11466 handler: &mut ___H,
11467 mut message: ::fidl_next::Message<___T>,
11468 responder: ::fidl_next::protocol::Responder<___T>,
11469 ) -> ::core::result::Result<
11470 (),
11471 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
11472 > {
11473 match *message.header().ordinal {
11474 8165227925828473216 => {
11475 let responder = ::fidl_next::Responder::from_untyped(responder);
11476
11477 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11478 Ok(decoded) => {
11479 handler
11480 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
11481 .await;
11482 Ok(())
11483 }
11484 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11485 ordinal: 8165227925828473216,
11486 error,
11487 }),
11488 }
11489 }
11490
11491 9194435320863127852 => {
11492 let responder = ::fidl_next::Responder::from_untyped(responder);
11493
11494 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11495 Ok(decoded) => {
11496 handler
11497 .open_exposed_dir(
11498 ::fidl_next::Request::from_decoded(decoded),
11499 responder,
11500 )
11501 .await;
11502 Ok(())
11503 }
11504 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11505 ordinal: 9194435320863127852,
11506 error,
11507 }),
11508 }
11509 }
11510
11511 4892190024503489888 => {
11512 let responder = ::fidl_next::Responder::from_untyped(responder);
11513
11514 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11515 Ok(decoded) => {
11516 handler
11517 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
11518 .await;
11519 Ok(())
11520 }
11521 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11522 ordinal: 4892190024503489888,
11523 error,
11524 }),
11525 }
11526 }
11527
11528 8203529889988252194 => {
11529 let responder = ::fidl_next::Responder::from_untyped(responder);
11530
11531 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11532 Ok(decoded) => {
11533 handler
11534 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
11535 .await;
11536 Ok(())
11537 }
11538 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11539 ordinal: 8203529889988252194,
11540 error,
11541 }),
11542 }
11543 }
11544
11545 7532454435519185057 => {
11546 let responder = ::fidl_next::Responder::from_untyped(responder);
11547
11548 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11549 Ok(decoded) => {
11550 handler
11551 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
11552 .await;
11553 Ok(())
11554 }
11555 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11556 ordinal: 7532454435519185057,
11557 error,
11558 }),
11559 }
11560 }
11561
11562 8308987710372188322 => {
11563 let responder = ::fidl_next::Responder::from_untyped(responder);
11564
11565 handler.get_resolved_info(responder).await;
11566 Ok(())
11567 }
11568
11569 4117516026351534948 => {
11570 let responder = ::fidl_next::Responder::from_untyped(responder);
11571
11572 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11573 Ok(decoded) => {
11574 handler
11575 .get_child_output_dictionary_deprecated(
11576 ::fidl_next::Request::from_decoded(decoded),
11577 responder,
11578 )
11579 .await;
11580 Ok(())
11581 }
11582 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11583 ordinal: 4117516026351534948,
11584 error,
11585 }),
11586 }
11587 }
11588
11589 4781081784078915088 => {
11590 let responder = ::fidl_next::Responder::from_untyped(responder);
11591
11592 match ::fidl_next::AsDecoderExt::into_decoded(message) {
11593 Ok(decoded) => {
11594 handler
11595 .get_child_output_dictionary(
11596 ::fidl_next::Request::from_decoded(decoded),
11597 responder,
11598 )
11599 .await;
11600 Ok(())
11601 }
11602 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11603 ordinal: 4781081784078915088,
11604 error,
11605 }),
11606 }
11607 }
11608
11609 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11610 }
11611 }
11612}
11613
11614impl<___T> RealmClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
11615
11616impl<___H, ___T> RealmLocalClientHandler<___T> for ::fidl_next::Local<___H>
11617where
11618 ___H: RealmClientHandler<___T>,
11619 ___T: ::fidl_next::Transport,
11620{
11621}
11622
11623impl<___H, ___T> RealmLocalServerHandler<___T> for ::fidl_next::Local<___H>
11624where
11625 ___H: RealmServerHandler<___T>,
11626 ___T: ::fidl_next::Transport,
11627{
11628 async fn open_controller(
11629 &mut self,
11630
11631 request: ::fidl_next::Request<realm::OpenController, ___T>,
11632
11633 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
11634 ) {
11635 ___H::open_controller(&mut self.0, request, responder).await
11636 }
11637
11638 async fn open_exposed_dir(
11639 &mut self,
11640
11641 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
11642
11643 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
11644 ) {
11645 ___H::open_exposed_dir(&mut self.0, request, responder).await
11646 }
11647
11648 async fn create_child(
11649 &mut self,
11650
11651 request: ::fidl_next::Request<realm::CreateChild, ___T>,
11652
11653 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
11654 ) {
11655 ___H::create_child(&mut self.0, request, responder).await
11656 }
11657
11658 async fn destroy_child(
11659 &mut self,
11660
11661 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
11662
11663 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
11664 ) {
11665 ___H::destroy_child(&mut self.0, request, responder).await
11666 }
11667
11668 async fn list_children(
11669 &mut self,
11670
11671 request: ::fidl_next::Request<realm::ListChildren, ___T>,
11672
11673 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
11674 ) {
11675 ___H::list_children(&mut self.0, request, responder).await
11676 }
11677
11678 async fn get_resolved_info(
11679 &mut self,
11680
11681 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
11682 ) {
11683 ___H::get_resolved_info(&mut self.0, responder).await
11684 }
11685
11686 async fn get_child_output_dictionary_deprecated(
11687 &mut self,
11688
11689 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
11690
11691 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
11692 ) {
11693 ___H::get_child_output_dictionary_deprecated(&mut self.0, request, responder).await
11694 }
11695
11696 async fn get_child_output_dictionary(
11697 &mut self,
11698
11699 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
11700
11701 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
11702 ) {
11703 ___H::get_child_output_dictionary(&mut self.0, request, responder).await
11704 }
11705}
11706
11707#[derive(PartialEq, Debug)]
11709pub struct StorageAdmin;
11710
11711impl ::fidl_next::Discoverable for StorageAdmin {
11712 const PROTOCOL_NAME: &'static str = "fuchsia.component.StorageAdmin";
11713}
11714
11715#[cfg(target_os = "fuchsia")]
11716impl ::fidl_next::HasTransport for StorageAdmin {
11717 type Transport = ::fidl_next::fuchsia::zx::Channel;
11718}
11719
11720pub mod storage_admin {
11721 pub mod prelude {
11722 pub use crate::{
11723 StorageAdmin, StorageAdminClientHandler, StorageAdminLocalClientHandler,
11724 StorageAdminLocalServerHandler, StorageAdminServerHandler, storage_admin,
11725 };
11726
11727 pub use crate::natural::DeletionError;
11728
11729 pub use crate::natural::Error;
11730
11731 pub use crate::natural::StatusError;
11732
11733 pub use crate::natural::StorageAdminDeleteComponentStorageRequest;
11734
11735 pub use crate::natural::StorageAdminListStorageInRealmRequest;
11736
11737 pub use crate::natural::StorageAdminOpenComponentStorageByIdRequest;
11738
11739 pub use crate::natural::StorageAdminOpenStorageRequest;
11740
11741 pub use crate::natural::StorageAdminDeleteAllStorageContentsResponse;
11742
11743 pub use crate::natural::StorageAdminDeleteComponentStorageResponse;
11744
11745 pub use crate::natural::StorageAdminListStorageInRealmResponse;
11746
11747 pub use crate::natural::StorageAdminOpenComponentStorageByIdResponse;
11748
11749 pub use crate::natural::StorageAdminOpenStorageResponse;
11750
11751 pub use crate::natural::StorageStatus;
11752 }
11753
11754 pub struct OpenStorage;
11755
11756 impl ::fidl_next::Method for OpenStorage {
11757 const ORDINAL: u64 = 7848267339832116087;
11758 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11759 ::fidl_next::protocol::Flexibility::Strict;
11760
11761 type Protocol = crate::StorageAdmin;
11762
11763 type Request = crate::wire::StorageAdminOpenStorageRequest<'static>;
11764 }
11765
11766 impl ::fidl_next::TwoWayMethod for OpenStorage {
11767 type Response = ::fidl_next::wire::Result<
11768 'static,
11769 crate::wire::StorageAdminOpenStorageResponse,
11770 crate::wire::Error,
11771 >;
11772 }
11773
11774 impl<___R> ::fidl_next::Respond<___R> for OpenStorage {
11775 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11776
11777 fn respond(response: ___R) -> Self::Output {
11778 ::core::result::Result::Ok(response)
11779 }
11780 }
11781
11782 impl<___R> ::fidl_next::RespondErr<___R> for OpenStorage {
11783 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11784
11785 fn respond_err(response: ___R) -> Self::Output {
11786 ::core::result::Result::Err(response)
11787 }
11788 }
11789
11790 pub struct ListStorageInRealm;
11791
11792 impl ::fidl_next::Method for ListStorageInRealm {
11793 const ORDINAL: u64 = 8525152599685368827;
11794 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11795 ::fidl_next::protocol::Flexibility::Strict;
11796
11797 type Protocol = crate::StorageAdmin;
11798
11799 type Request = crate::wire::StorageAdminListStorageInRealmRequest<'static>;
11800 }
11801
11802 impl ::fidl_next::TwoWayMethod for ListStorageInRealm {
11803 type Response = ::fidl_next::wire::Result<
11804 'static,
11805 crate::wire::StorageAdminListStorageInRealmResponse,
11806 crate::wire::Error,
11807 >;
11808 }
11809
11810 impl<___R> ::fidl_next::Respond<___R> for ListStorageInRealm {
11811 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11812
11813 fn respond(response: ___R) -> Self::Output {
11814 ::core::result::Result::Ok(response)
11815 }
11816 }
11817
11818 impl<___R> ::fidl_next::RespondErr<___R> for ListStorageInRealm {
11819 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11820
11821 fn respond_err(response: ___R) -> Self::Output {
11822 ::core::result::Result::Err(response)
11823 }
11824 }
11825
11826 pub struct OpenComponentStorageById;
11827
11828 impl ::fidl_next::Method for OpenComponentStorageById {
11829 const ORDINAL: u64 = 5188727505160068593;
11830 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11831 ::fidl_next::protocol::Flexibility::Strict;
11832
11833 type Protocol = crate::StorageAdmin;
11834
11835 type Request = crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>;
11836 }
11837
11838 impl ::fidl_next::TwoWayMethod for OpenComponentStorageById {
11839 type Response = ::fidl_next::wire::Result<
11840 'static,
11841 crate::wire::StorageAdminOpenComponentStorageByIdResponse,
11842 crate::wire::Error,
11843 >;
11844 }
11845
11846 impl<___R> ::fidl_next::Respond<___R> for OpenComponentStorageById {
11847 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11848
11849 fn respond(response: ___R) -> Self::Output {
11850 ::core::result::Result::Ok(response)
11851 }
11852 }
11853
11854 impl<___R> ::fidl_next::RespondErr<___R> for OpenComponentStorageById {
11855 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11856
11857 fn respond_err(response: ___R) -> Self::Output {
11858 ::core::result::Result::Err(response)
11859 }
11860 }
11861
11862 pub struct DeleteComponentStorage;
11863
11864 impl ::fidl_next::Method for DeleteComponentStorage {
11865 const ORDINAL: u64 = 1618975681517712474;
11866 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11867 ::fidl_next::protocol::Flexibility::Strict;
11868
11869 type Protocol = crate::StorageAdmin;
11870
11871 type Request = crate::wire::StorageAdminDeleteComponentStorageRequest<'static>;
11872 }
11873
11874 impl ::fidl_next::TwoWayMethod for DeleteComponentStorage {
11875 type Response = ::fidl_next::wire::Result<
11876 'static,
11877 crate::wire::StorageAdminDeleteComponentStorageResponse,
11878 crate::wire::Error,
11879 >;
11880 }
11881
11882 impl<___R> ::fidl_next::Respond<___R> for DeleteComponentStorage {
11883 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11884
11885 fn respond(response: ___R) -> Self::Output {
11886 ::core::result::Result::Ok(response)
11887 }
11888 }
11889
11890 impl<___R> ::fidl_next::RespondErr<___R> for DeleteComponentStorage {
11891 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11892
11893 fn respond_err(response: ___R) -> Self::Output {
11894 ::core::result::Result::Err(response)
11895 }
11896 }
11897
11898 pub struct GetStatus;
11899
11900 impl ::fidl_next::Method for GetStatus {
11901 const ORDINAL: u64 = 8586643915409794760;
11902 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11903 ::fidl_next::protocol::Flexibility::Strict;
11904
11905 type Protocol = crate::StorageAdmin;
11906
11907 type Request = ::fidl_next::wire::EmptyMessageBody;
11908 }
11909
11910 impl ::fidl_next::TwoWayMethod for GetStatus {
11911 type Response = ::fidl_next::wire::Result<
11912 'static,
11913 crate::wire::StorageStatus<'static>,
11914 crate::wire::StatusError,
11915 >;
11916 }
11917
11918 impl<___R> ::fidl_next::Respond<___R> for GetStatus {
11919 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11920
11921 fn respond(response: ___R) -> Self::Output {
11922 ::core::result::Result::Ok(response)
11923 }
11924 }
11925
11926 impl<___R> ::fidl_next::RespondErr<___R> for GetStatus {
11927 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11928
11929 fn respond_err(response: ___R) -> Self::Output {
11930 ::core::result::Result::Err(response)
11931 }
11932 }
11933
11934 pub struct DeleteAllStorageContents;
11935
11936 impl ::fidl_next::Method for DeleteAllStorageContents {
11937 const ORDINAL: u64 = 3380374508900862683;
11938 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
11939 ::fidl_next::protocol::Flexibility::Strict;
11940
11941 type Protocol = crate::StorageAdmin;
11942
11943 type Request = ::fidl_next::wire::EmptyMessageBody;
11944 }
11945
11946 impl ::fidl_next::TwoWayMethod for DeleteAllStorageContents {
11947 type Response = ::fidl_next::wire::Result<
11948 'static,
11949 crate::wire::StorageAdminDeleteAllStorageContentsResponse,
11950 crate::wire::DeletionError,
11951 >;
11952 }
11953
11954 impl<___R> ::fidl_next::Respond<___R> for DeleteAllStorageContents {
11955 type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;
11956
11957 fn respond(response: ___R) -> Self::Output {
11958 ::core::result::Result::Ok(response)
11959 }
11960 }
11961
11962 impl<___R> ::fidl_next::RespondErr<___R> for DeleteAllStorageContents {
11963 type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;
11964
11965 fn respond_err(response: ___R) -> Self::Output {
11966 ::core::result::Result::Err(response)
11967 }
11968 }
11969
11970 mod ___detail {
11971 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageAdmin
11972 where
11973 ___T: ::fidl_next::Transport,
11974 {
11975 type Client = StorageAdminClient<___T>;
11976 type Server = StorageAdminServer<___T>;
11977 }
11978
11979 #[repr(transparent)]
11981 pub struct StorageAdminClient<___T: ::fidl_next::Transport> {
11982 #[allow(dead_code)]
11983 client: ::fidl_next::protocol::Client<___T>,
11984 }
11985
11986 impl<___T> StorageAdminClient<___T>
11987 where
11988 ___T: ::fidl_next::Transport,
11989 {
11990 #[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"]
11991 pub fn open_storage(
11992 &self,
11993
11994 relative_moniker: impl ::fidl_next::Encode<
11995 ::fidl_next::wire::String<'static>,
11996 <___T as ::fidl_next::Transport>::SendBuffer,
11997 >,
11998
11999 object: impl ::fidl_next::Encode<
12000 ::fidl_next::ServerEnd<
12001 ::fidl_next_fuchsia_io::Node,
12002 ::fidl_next::wire::fuchsia::Channel,
12003 >,
12004 <___T as ::fidl_next::Transport>::SendBuffer,
12005 >,
12006 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
12007 where
12008 <___T as ::fidl_next::Transport>::SendBuffer:
12009 ::fidl_next::encoder::InternalHandleEncoder,
12010 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12011 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12012 {
12013 self.open_storage_with(crate::generic::StorageAdminOpenStorageRequest {
12014 relative_moniker,
12015
12016 object,
12017 })
12018 }
12019
12020 #[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"]
12021 pub fn open_storage_with<___R>(
12022 &self,
12023 request: ___R,
12024 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
12025 where
12026 ___R: ::fidl_next::Encode<
12027 crate::wire::StorageAdminOpenStorageRequest<'static>,
12028 <___T as ::fidl_next::Transport>::SendBuffer,
12029 >,
12030 {
12031 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12032 7848267339832116087,
12033 <super::OpenStorage as ::fidl_next::Method>::FLEXIBILITY,
12034 request,
12035 ))
12036 }
12037
12038 #[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"]
12039 pub fn list_storage_in_realm(
12040 &self,
12041
12042 relative_moniker: impl ::fidl_next::Encode<
12043 ::fidl_next::wire::String<'static>,
12044 <___T as ::fidl_next::Transport>::SendBuffer,
12045 >,
12046
12047 iterator: impl ::fidl_next::Encode<
12048 ::fidl_next::ServerEnd<
12049 crate::StorageIterator,
12050 ::fidl_next::wire::fuchsia::Channel,
12051 >,
12052 <___T as ::fidl_next::Transport>::SendBuffer,
12053 >,
12054 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
12055 where
12056 <___T as ::fidl_next::Transport>::SendBuffer:
12057 ::fidl_next::encoder::InternalHandleEncoder,
12058 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12059 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12060 {
12061 self.list_storage_in_realm_with(
12062 crate::generic::StorageAdminListStorageInRealmRequest {
12063 relative_moniker,
12064
12065 iterator,
12066 },
12067 )
12068 }
12069
12070 #[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"]
12071 pub fn list_storage_in_realm_with<___R>(
12072 &self,
12073 request: ___R,
12074 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
12075 where
12076 ___R: ::fidl_next::Encode<
12077 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
12078 <___T as ::fidl_next::Transport>::SendBuffer,
12079 >,
12080 {
12081 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12082 8525152599685368827,
12083 <super::ListStorageInRealm as ::fidl_next::Method>::FLEXIBILITY,
12084 request,
12085 ))
12086 }
12087
12088 #[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"]
12089 pub fn open_component_storage_by_id(
12090 &self,
12091
12092 id: impl ::fidl_next::Encode<
12093 ::fidl_next::wire::String<'static>,
12094 <___T as ::fidl_next::Transport>::SendBuffer,
12095 >,
12096
12097 object: impl ::fidl_next::Encode<
12098 ::fidl_next::ServerEnd<
12099 ::fidl_next_fuchsia_io::Node,
12100 ::fidl_next::wire::fuchsia::Channel,
12101 >,
12102 <___T as ::fidl_next::Transport>::SendBuffer,
12103 >,
12104 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
12105 where
12106 <___T as ::fidl_next::Transport>::SendBuffer:
12107 ::fidl_next::encoder::InternalHandleEncoder,
12108 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12109 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
12110 {
12111 self.open_component_storage_by_id_with(
12112 crate::generic::StorageAdminOpenComponentStorageByIdRequest { id, object },
12113 )
12114 }
12115
12116 #[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"]
12117 pub fn open_component_storage_by_id_with<___R>(
12118 &self,
12119 request: ___R,
12120 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
12121 where
12122 ___R: ::fidl_next::Encode<
12123 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
12124 <___T as ::fidl_next::Transport>::SendBuffer,
12125 >,
12126 {
12127 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12128 5188727505160068593,
12129 <super::OpenComponentStorageById as ::fidl_next::Method>::FLEXIBILITY,
12130 request,
12131 ))
12132 }
12133
12134 #[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"]
12135 pub fn delete_component_storage(
12136 &self,
12137
12138 relative_moniker: impl ::fidl_next::Encode<
12139 ::fidl_next::wire::String<'static>,
12140 <___T as ::fidl_next::Transport>::SendBuffer,
12141 >,
12142 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
12143 where
12144 <___T as ::fidl_next::Transport>::SendBuffer:
12145 ::fidl_next::encoder::InternalHandleEncoder,
12146 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
12147 {
12148 self.delete_component_storage_with(
12149 crate::generic::StorageAdminDeleteComponentStorageRequest { relative_moniker },
12150 )
12151 }
12152
12153 #[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"]
12154 pub fn delete_component_storage_with<___R>(
12155 &self,
12156 request: ___R,
12157 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
12158 where
12159 ___R: ::fidl_next::Encode<
12160 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
12161 <___T as ::fidl_next::Transport>::SendBuffer,
12162 >,
12163 {
12164 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
12165 1618975681517712474,
12166 <super::DeleteComponentStorage as ::fidl_next::Method>::FLEXIBILITY,
12167 request,
12168 ))
12169 }
12170
12171 #[doc = " Get the current status of the storage.\n"]
12172 pub fn get_status(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetStatus, ___T> {
12173 ::fidl_next::TwoWayFuture::from_untyped(
12174 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12175 8586643915409794760,
12176 <super::GetStatus as ::fidl_next::Method>::FLEXIBILITY,
12177 (),
12178 ),
12179 )
12180 }
12181
12182 #[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"]
12183 pub fn delete_all_storage_contents(
12184 &self,
12185 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteAllStorageContents, ___T> {
12186 ::fidl_next::TwoWayFuture::from_untyped(
12187 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
12188 3380374508900862683,
12189 <super::DeleteAllStorageContents as ::fidl_next::Method>::FLEXIBILITY,
12190 (),
12191 ),
12192 )
12193 }
12194 }
12195
12196 #[repr(transparent)]
12198 pub struct StorageAdminServer<___T: ::fidl_next::Transport> {
12199 server: ::fidl_next::protocol::Server<___T>,
12200 }
12201
12202 impl<___T> StorageAdminServer<___T> where ___T: ::fidl_next::Transport {}
12203 }
12204}
12205
12206#[diagnostic::on_unimplemented(
12207 note = "If {Self} implements the non-local StorageAdminClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
12208)]
12209
12210pub trait StorageAdminLocalClientHandler<
12214 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12215 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12216>
12217{
12218}
12219
12220impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for StorageAdmin
12221where
12222 ___H: StorageAdminLocalClientHandler<___T>,
12223 ___T: ::fidl_next::Transport,
12224{
12225 async fn on_event(
12226 handler: &mut ___H,
12227 mut message: ::fidl_next::Message<___T>,
12228 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12229 match *message.header().ordinal {
12230 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12231 }
12232 }
12233}
12234
12235#[diagnostic::on_unimplemented(
12236 note = "If {Self} implements the non-local StorageAdminServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
12237)]
12238
12239pub trait StorageAdminLocalServerHandler<
12243 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12244 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12245>
12246{
12247 #[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"]
12248 fn open_storage(
12249 &mut self,
12250
12251 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12252
12253 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12254 ) -> impl ::core::future::Future<Output = ()>;
12255
12256 #[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"]
12257 fn list_storage_in_realm(
12258 &mut self,
12259
12260 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12261
12262 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12263 ) -> impl ::core::future::Future<Output = ()>;
12264
12265 #[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"]
12266 fn open_component_storage_by_id(
12267 &mut self,
12268
12269 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12270
12271 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12272 ) -> impl ::core::future::Future<Output = ()>;
12273
12274 #[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"]
12275 fn delete_component_storage(
12276 &mut self,
12277
12278 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12279
12280 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12281 ) -> impl ::core::future::Future<Output = ()>;
12282
12283 #[doc = " Get the current status of the storage.\n"]
12284 fn get_status(
12285 &mut self,
12286
12287 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12288 ) -> impl ::core::future::Future<Output = ()>;
12289
12290 #[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"]
12291 fn delete_all_storage_contents(
12292 &mut self,
12293
12294 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12295 ) -> impl ::core::future::Future<Output = ()>;
12296}
12297
12298impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for StorageAdmin
12299where
12300 ___H: StorageAdminLocalServerHandler<___T>,
12301 ___T: ::fidl_next::Transport,
12302 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12303 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12304 Constraint = (),
12305 >,
12306 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12307 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12308 Constraint = (),
12309 >,
12310 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12311 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12312 Constraint = (),
12313 >,
12314 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12315 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12316 Constraint = (),
12317 >,
12318{
12319 async fn on_one_way(
12320 handler: &mut ___H,
12321 mut message: ::fidl_next::Message<___T>,
12322 ) -> ::core::result::Result<
12323 (),
12324 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12325 > {
12326 match *message.header().ordinal {
12327 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12328 }
12329 }
12330
12331 async fn on_two_way(
12332 handler: &mut ___H,
12333 mut message: ::fidl_next::Message<___T>,
12334 responder: ::fidl_next::protocol::Responder<___T>,
12335 ) -> ::core::result::Result<
12336 (),
12337 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12338 > {
12339 match *message.header().ordinal {
12340 7848267339832116087 => {
12341 let responder = ::fidl_next::Responder::from_untyped(responder);
12342
12343 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12344 Ok(decoded) => {
12345 handler
12346 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12347 .await;
12348 Ok(())
12349 }
12350 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12351 ordinal: 7848267339832116087,
12352 error,
12353 }),
12354 }
12355 }
12356
12357 8525152599685368827 => {
12358 let responder = ::fidl_next::Responder::from_untyped(responder);
12359
12360 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12361 Ok(decoded) => {
12362 handler
12363 .list_storage_in_realm(
12364 ::fidl_next::Request::from_decoded(decoded),
12365 responder,
12366 )
12367 .await;
12368 Ok(())
12369 }
12370 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12371 ordinal: 8525152599685368827,
12372 error,
12373 }),
12374 }
12375 }
12376
12377 5188727505160068593 => {
12378 let responder = ::fidl_next::Responder::from_untyped(responder);
12379
12380 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12381 Ok(decoded) => {
12382 handler
12383 .open_component_storage_by_id(
12384 ::fidl_next::Request::from_decoded(decoded),
12385 responder,
12386 )
12387 .await;
12388 Ok(())
12389 }
12390 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12391 ordinal: 5188727505160068593,
12392 error,
12393 }),
12394 }
12395 }
12396
12397 1618975681517712474 => {
12398 let responder = ::fidl_next::Responder::from_untyped(responder);
12399
12400 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12401 Ok(decoded) => {
12402 handler
12403 .delete_component_storage(
12404 ::fidl_next::Request::from_decoded(decoded),
12405 responder,
12406 )
12407 .await;
12408 Ok(())
12409 }
12410 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12411 ordinal: 1618975681517712474,
12412 error,
12413 }),
12414 }
12415 }
12416
12417 8586643915409794760 => {
12418 let responder = ::fidl_next::Responder::from_untyped(responder);
12419
12420 handler.get_status(responder).await;
12421 Ok(())
12422 }
12423
12424 3380374508900862683 => {
12425 let responder = ::fidl_next::Responder::from_untyped(responder);
12426
12427 handler.delete_all_storage_contents(responder).await;
12428 Ok(())
12429 }
12430
12431 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12432 }
12433 }
12434}
12435
12436pub trait StorageAdminClientHandler<
12440 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12441 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12442>
12443{
12444}
12445
12446impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageAdmin
12447where
12448 ___H: StorageAdminClientHandler<___T> + ::core::marker::Send,
12449 ___T: ::fidl_next::Transport,
12450{
12451 async fn on_event(
12452 handler: &mut ___H,
12453 mut message: ::fidl_next::Message<___T>,
12454 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
12455 match *message.header().ordinal {
12456 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12457 }
12458 }
12459}
12460
12461pub trait StorageAdminServerHandler<
12465 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
12466 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
12467>
12468{
12469 #[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"]
12470 fn open_storage(
12471 &mut self,
12472
12473 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12474
12475 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12476 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12477
12478 #[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"]
12479 fn list_storage_in_realm(
12480 &mut self,
12481
12482 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12483
12484 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12485 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12486
12487 #[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"]
12488 fn open_component_storage_by_id(
12489 &mut self,
12490
12491 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12492
12493 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12494 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12495
12496 #[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"]
12497 fn delete_component_storage(
12498 &mut self,
12499
12500 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12501
12502 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12503 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12504
12505 #[doc = " Get the current status of the storage.\n"]
12506 fn get_status(
12507 &mut self,
12508
12509 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12510 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12511
12512 #[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"]
12513 fn delete_all_storage_contents(
12514 &mut self,
12515
12516 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12517 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
12518}
12519
12520impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageAdmin
12521where
12522 ___H: StorageAdminServerHandler<___T> + ::core::marker::Send,
12523 ___T: ::fidl_next::Transport,
12524 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
12525 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12526 Constraint = (),
12527 >,
12528 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
12529 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12530 Constraint = (),
12531 >,
12532 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
12533 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12534 Constraint = (),
12535 >,
12536 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
12537 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
12538 Constraint = (),
12539 >,
12540{
12541 async fn on_one_way(
12542 handler: &mut ___H,
12543 mut message: ::fidl_next::Message<___T>,
12544 ) -> ::core::result::Result<
12545 (),
12546 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12547 > {
12548 match *message.header().ordinal {
12549 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12550 }
12551 }
12552
12553 async fn on_two_way(
12554 handler: &mut ___H,
12555 mut message: ::fidl_next::Message<___T>,
12556 responder: ::fidl_next::protocol::Responder<___T>,
12557 ) -> ::core::result::Result<
12558 (),
12559 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
12560 > {
12561 match *message.header().ordinal {
12562 7848267339832116087 => {
12563 let responder = ::fidl_next::Responder::from_untyped(responder);
12564
12565 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12566 Ok(decoded) => {
12567 handler
12568 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
12569 .await;
12570 Ok(())
12571 }
12572 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12573 ordinal: 7848267339832116087,
12574 error,
12575 }),
12576 }
12577 }
12578
12579 8525152599685368827 => {
12580 let responder = ::fidl_next::Responder::from_untyped(responder);
12581
12582 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12583 Ok(decoded) => {
12584 handler
12585 .list_storage_in_realm(
12586 ::fidl_next::Request::from_decoded(decoded),
12587 responder,
12588 )
12589 .await;
12590 Ok(())
12591 }
12592 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12593 ordinal: 8525152599685368827,
12594 error,
12595 }),
12596 }
12597 }
12598
12599 5188727505160068593 => {
12600 let responder = ::fidl_next::Responder::from_untyped(responder);
12601
12602 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12603 Ok(decoded) => {
12604 handler
12605 .open_component_storage_by_id(
12606 ::fidl_next::Request::from_decoded(decoded),
12607 responder,
12608 )
12609 .await;
12610 Ok(())
12611 }
12612 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12613 ordinal: 5188727505160068593,
12614 error,
12615 }),
12616 }
12617 }
12618
12619 1618975681517712474 => {
12620 let responder = ::fidl_next::Responder::from_untyped(responder);
12621
12622 match ::fidl_next::AsDecoderExt::into_decoded(message) {
12623 Ok(decoded) => {
12624 handler
12625 .delete_component_storage(
12626 ::fidl_next::Request::from_decoded(decoded),
12627 responder,
12628 )
12629 .await;
12630 Ok(())
12631 }
12632 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
12633 ordinal: 1618975681517712474,
12634 error,
12635 }),
12636 }
12637 }
12638
12639 8586643915409794760 => {
12640 let responder = ::fidl_next::Responder::from_untyped(responder);
12641
12642 handler.get_status(responder).await;
12643 Ok(())
12644 }
12645
12646 3380374508900862683 => {
12647 let responder = ::fidl_next::Responder::from_untyped(responder);
12648
12649 handler.delete_all_storage_contents(responder).await;
12650 Ok(())
12651 }
12652
12653 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
12654 }
12655 }
12656}
12657
12658impl<___T> StorageAdminClientHandler<___T> for ::fidl_next::IgnoreEvents where
12659 ___T: ::fidl_next::Transport
12660{
12661}
12662
12663impl<___H, ___T> StorageAdminLocalClientHandler<___T> for ::fidl_next::Local<___H>
12664where
12665 ___H: StorageAdminClientHandler<___T>,
12666 ___T: ::fidl_next::Transport,
12667{
12668}
12669
12670impl<___H, ___T> StorageAdminLocalServerHandler<___T> for ::fidl_next::Local<___H>
12671where
12672 ___H: StorageAdminServerHandler<___T>,
12673 ___T: ::fidl_next::Transport,
12674{
12675 async fn open_storage(
12676 &mut self,
12677
12678 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
12679
12680 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
12681 ) {
12682 ___H::open_storage(&mut self.0, request, responder).await
12683 }
12684
12685 async fn list_storage_in_realm(
12686 &mut self,
12687
12688 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
12689
12690 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
12691 ) {
12692 ___H::list_storage_in_realm(&mut self.0, request, responder).await
12693 }
12694
12695 async fn open_component_storage_by_id(
12696 &mut self,
12697
12698 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
12699
12700 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
12701 ) {
12702 ___H::open_component_storage_by_id(&mut self.0, request, responder).await
12703 }
12704
12705 async fn delete_component_storage(
12706 &mut self,
12707
12708 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
12709
12710 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
12711 ) {
12712 ___H::delete_component_storage(&mut self.0, request, responder).await
12713 }
12714
12715 async fn get_status(
12716 &mut self,
12717
12718 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
12719 ) {
12720 ___H::get_status(&mut self.0, responder).await
12721 }
12722
12723 async fn delete_all_storage_contents(
12724 &mut self,
12725
12726 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
12727 ) {
12728 ___H::delete_all_storage_contents(&mut self.0, responder).await
12729 }
12730}
12731
12732pub use fidl_next_common_fuchsia_component::*;